@opentui/keymap 0.2.1 → 0.2.3

package/index.js

@@ -1,4411 +0,0 @@
-// @bun
-// src/services/primitives/active-layers.ts
-function getFocusedTargetIfAvailable(host) {
-  if (host.isDestroyed) {
-    return null;
-  }
-  return host.getFocusedTarget();
-}
-function forEachActivationTarget(host, focused, visit) {
-  let current = focused ?? host.rootTarget;
-  let isFocusedTarget = focused !== null;
-  while (current) {
-    const shouldContinue = visit(current, isFocusedTarget);
-    if (shouldContinue === false) {
-      return;
-    }
-    current = host.getParentTarget(current);
-    isFocusedTarget = false;
-  }
-}
-function getActivationPath(host, focused) {
-  const path = new Set;
-  forEachActivationTarget(host, focused, (current) => {
-    path.add(current);
-  });
-  return path;
-}
-function getActiveLayersForFocused(state, host, focused) {
-  if (state.activeLayersCacheVersion === state.activeLayersVersion && state.activeLayersCacheFocused === focused) {
-    return state.activeLayersCache;
-  }
-  const activeLayers = [];
-  const activationPath = getActivationPath(host, focused);
-  for (const layer of state.sortedLayers) {
-    if (isLayerActiveForFocused(host, layer, focused, activationPath)) {
-      activeLayers.push(layer);
-    }
-  }
-  state.activeLayersCacheVersion = state.activeLayersVersion;
-  state.activeLayersCacheFocused = focused;
-  state.activeLayersCache = activeLayers;
-  return activeLayers;
-}
-function invalidateCachedActiveLayers(state) {
-  state.activeLayersCacheVersion = -1;
-  state.activeLayersCacheFocused = undefined;
-  state.activeLayersCache = [];
-}
-function isLayerActiveForFocused(host, layer, focused, activationPath = getActivationPath(host, focused)) {
-  const target = layer.target;
-  if (!target) {
-    return true;
-  }
-  if (host.isTargetDestroyed(target)) {
-    return false;
-  }
-  if (layer.targetMode === "focus") {
-    return target === focused;
-  }
-  return activationPath.has(target);
-}
-
-// src/services/keys.ts
-function normalizeBindingTokenName(token) {
-  const normalized = token.trim().toLowerCase();
-  if (!normalized) {
-    throw new Error("Invalid keymap token: token cannot be empty");
-  }
-  return normalized;
-}
-function normalizeKeyName(name) {
-  const normalized = name.trim().toLowerCase();
-  if (!normalized) {
-    throw new Error("Invalid key name: key name cannot be empty");
-  }
-  return normalized;
-}
-function normalizeKeyStroke(input) {
-  return {
-    name: normalizeKeyName(input.name),
-    ctrl: input.ctrl ?? false,
-    shift: input.shift ?? false,
-    meta: input.meta ?? false,
-    super: input.super ?? false,
-    hyper: input.hyper || undefined
-  };
-}
-function cloneKeyStroke(stroke) {
-  return {
-    name: stroke.name,
-    ctrl: stroke.ctrl,
-    shift: stroke.shift,
-    meta: stroke.meta,
-    super: stroke.super,
-    hyper: stroke.hyper || undefined
-  };
-}
-function createKeySequencePart(input, options) {
-  const stroke = cloneKeyStroke(normalizeKeyStroke(input));
-  return {
-    stroke,
-    display: options?.display ?? stringifyCanonicalStroke(stroke),
-    match: options?.match ?? createKeyMatch(stroke),
-    tokenName: options?.tokenName ? normalizeBindingTokenName(options.tokenName) : undefined
-  };
-}
-function cloneKeySequencePart(part) {
-  return {
-    stroke: cloneKeyStroke(part.stroke),
-    display: part.display,
-    match: part.match,
-    tokenName: part.tokenName
-  };
-}
-function cloneKeySequence(parts) {
-  return parts.map((part) => cloneKeySequencePart(part));
-}
-function resolveKeyMatch(input) {
-  if ("match" in input) {
-    return input.match;
-  }
-  if ("stroke" in input) {
-    return createKeyMatch(input.stroke);
-  }
-  return createKeyMatch(input);
-}
-function createKeyMatch(input) {
-  return `key:${buildKeyMatchId(normalizeKeyStroke(input))}`;
-}
-function createTextKeyMatch(id) {
-  const normalized = id.trim();
-  if (!normalized) {
-    throw new Error("Invalid keymap match id: id cannot be empty");
-  }
-  return `text:${normalized}`;
-}
-function stringifyKeyStroke(input, options) {
-  if ("stroke" in input) {
-    if (options?.preferDisplay && input.display) {
-      return input.display;
-    }
-    return stringifyCanonicalStroke(input.stroke);
-  }
-  return stringifyCanonicalStroke(normalizeKeyStroke(input));
-}
-function stringifyKeySequence(input, options) {
-  return input.map((part) => stringifyKeyStroke(part, options)).join("");
-}
-function stringifyCanonicalStroke(stroke) {
-  const parts = [];
-  if (stroke.ctrl) {
-    parts.push("ctrl");
-  }
-  if (stroke.shift) {
-    parts.push("shift");
-  }
-  if (stroke.meta) {
-    parts.push("meta");
-  }
-  if (stroke.super) {
-    parts.push("super");
-  }
-  if (stroke.hyper) {
-    parts.push("hyper");
-  }
-  parts.push(stroke.name === "return" ? "enter" : stroke.name);
-  return parts.join("+");
-}
-function buildKeyMatchId(stroke) {
-  return `${stroke.name}:${stroke.ctrl ? 1 : 0}:${stroke.shift ? 1 : 0}:${stroke.meta ? 1 : 0}:${stroke.super ? 1 : 0}:${stroke.hyper ? 1 : 0}`;
-}
-
-// src/services/activation.ts
-function getLiveHost(host) {
-  if (host.isDestroyed) {
-    throw new Error("Cannot use a keymap after its host was destroyed");
-  }
-  return host;
-}
-function isSamePendingSequence(current, next) {
-  if (current === next) {
-    return true;
-  }
-  if (!current || !next) {
-    return false;
-  }
-  if (current.captures.length !== next.captures.length) {
-    return false;
-  }
-  for (let index = 0;index < current.captures.length; index += 1) {
-    const left = current.captures[index];
-    const right = next.captures[index];
-    if (!left || !right || left.layer !== right.layer || left.node !== right.node) {
-      return false;
-    }
-  }
-  return true;
-}
-
-class ActivationService {
-  state;
-  host;
-  hooks;
-  notify;
-  conditions;
-  catalog;
-  options;
-  constructor(state, host, hooks, notify, conditions, catalog, options = {}) {
-    this.state = state;
-    this.host = host;
-    this.hooks = hooks;
-    this.notify = notify;
-    this.conditions = conditions;
-    this.catalog = catalog;
-    this.options = options;
-  }
-  getFocusedTarget() {
-    return getLiveHost(this.host).getFocusedTarget();
-  }
-  getFocusedTargetIfAvailable() {
-    return getFocusedTargetIfAvailable(this.host);
-  }
-  setPendingSequence(next) {
-    const previous = this.state.projection.pendingSequence;
-    if (isSamePendingSequence(previous, next)) {
-      return;
-    }
-    this.state.projection.pendingSequence = next;
-    this.options.onPendingSequenceChanged?.(previous, next);
-    this.invalidateCaches();
-    this.notifyPendingSequenceChange();
-    this.notify.queueStateChange();
-  }
-  ensureValidPendingSequence() {
-    const pending = this.state.projection.pendingSequence;
-    if (!pending) {
-      return;
-    }
-    const focused = this.getFocusedTarget();
-    const captures = pending.captures.filter((capture) => {
-      return this.state.layers.layers.has(capture.layer) && this.isLayerActiveForFocused(capture.layer, focused) && this.conditions.layerMatchesRuntimeState(capture.layer) && this.nodeHasReachableBindings(capture.node, focused);
-    });
-    if (captures.length === 0) {
-      this.setPendingSequence(null);
-      return;
-    }
-    if (captures.length !== pending.captures.length) {
-      this.setPendingSequence({ captures });
-    }
-    return this.state.projection.pendingSequence ?? undefined;
-  }
-  revalidatePendingSequenceIfNeeded() {
-    if (this.host.isDestroyed || !this.state.projection.pendingSequence) {
-      return;
-    }
-    this.ensureValidPendingSequence();
-  }
-  hasPendingSequenceState() {
-    return !this.host.isDestroyed && this.state.projection.pendingSequence !== null;
-  }
-  getPendingSequence() {
-    const projections = this.state.projection;
-    const derivedStateVersion = this.state.notify.derivedStateVersion;
-    if (projections.pendingSequenceCacheVersion === derivedStateVersion) {
-      return projections.pendingSequenceCache;
-    }
-    const pending = this.ensureValidPendingSequence();
-    const canUseCache = !pending || pending.captures.every((capture) => this.layerCanCacheActiveKeys(capture.layer));
-    const sequence = pending ? this.collectSequencePartsFromPending(pending) : [];
-    if (canUseCache) {
-      projections.pendingSequenceCacheVersion = derivedStateVersion;
-      projections.pendingSequenceCache = sequence;
-    }
-    return sequence;
-  }
-  popPendingSequence() {
-    const pending = this.ensureValidPendingSequence();
-    if (!pending) {
-      return false;
-    }
-    const firstCapture = pending.captures[0];
-    if (!firstCapture || firstCapture.node.depth <= 1) {
-      this.setPendingSequence(null);
-      return true;
-    }
-    const nextCaptures = [];
-    for (const capture of pending.captures) {
-      const parent = capture.node.parent;
-      if (!parent || !parent.stroke) {
-        continue;
-      }
-      nextCaptures.push({
-        layer: capture.layer,
-        node: parent
-      });
-    }
-    if (nextCaptures.length === 0) {
-      this.setPendingSequence(null);
-      return true;
-    }
-    this.setPendingSequence({ captures: nextCaptures });
-    return true;
-  }
-  getActiveKeys(options) {
-    const projections = this.state.projection;
-    const derivedStateVersion = this.state.notify.derivedStateVersion;
-    const includeBindings = options?.includeBindings === true;
-    const includeMetadata = options?.includeMetadata === true;
-    if (includeBindings) {
-      if (includeMetadata) {
-        if (projections.activeKeysBindingsAndMetadataCacheVersion === derivedStateVersion) {
-          return projections.activeKeysBindingsAndMetadataCache;
-        }
-      } else if (projections.activeKeysBindingsCacheVersion === derivedStateVersion) {
-        return projections.activeKeysBindingsCache;
-      }
-    } else if (includeMetadata) {
-      if (projections.activeKeysMetadataCacheVersion === derivedStateVersion) {
-        return projections.activeKeysMetadataCache;
-      }
-    } else if (projections.activeKeysPlainCacheVersion === derivedStateVersion) {
-      return projections.activeKeysPlainCache;
-    }
-    const focused = this.getFocusedTarget();
-    const activeView = this.catalog.getActiveCommandView(focused);
-    const pending = this.ensureValidPendingSequence();
-    const activeLayers = pending ? [] : this.getActiveLayers(focused);
-    const canUseCache = pending ? pending.captures.every((capture) => this.layerCanCacheActiveKeys(capture.layer)) : this.activeLayersCanCacheActiveKeys(activeLayers);
-    const activeKeys = pending ? this.collectActiveKeysFromPending(pending.captures, includeBindings, includeMetadata, focused, activeView) : this.collectActiveKeysAtRoot(activeLayers, includeBindings, includeMetadata, focused, activeView);
-    if (!canUseCache) {
-      return activeKeys;
-    }
-    if (includeBindings) {
-      if (includeMetadata) {
-        projections.activeKeysBindingsAndMetadataCacheVersion = derivedStateVersion;
-        projections.activeKeysBindingsAndMetadataCache = activeKeys;
-      } else {
-        projections.activeKeysBindingsCacheVersion = derivedStateVersion;
-        projections.activeKeysBindingsCache = activeKeys;
-      }
-    } else if (includeMetadata) {
-      projections.activeKeysMetadataCacheVersion = derivedStateVersion;
-      projections.activeKeysMetadataCache = activeKeys;
-    } else {
-      projections.activeKeysPlainCacheVersion = derivedStateVersion;
-      projections.activeKeysPlainCache = activeKeys;
-    }
-    return activeKeys;
-  }
-  getActiveKeysForCaptures(captures, options) {
-    const includeBindings = options?.includeBindings === true;
-    const includeMetadata = options?.includeMetadata === true;
-    const focused = this.getFocusedTarget();
-    const activeView = this.catalog.getActiveCommandView(focused);
-    return this.collectActiveKeysFromPending(captures, includeBindings, includeMetadata, focused, activeView);
-  }
-  nodeHasReachableBindings(node, focused) {
-    return this.hasMatchingBindings(node.reachableBindings, focused, this.catalog.getActiveCommandView(focused));
-  }
-  getActiveLayers(focused) {
-    return getActiveLayersForFocused(this.state.layers, this.host, focused);
-  }
-  refreshActiveLayers(focused = this.getFocusedTargetIfAvailable()) {
-    getActiveLayersForFocused(this.state.layers, this.host, focused);
-  }
-  invalidateActiveLayers() {
-    invalidateCachedActiveLayers(this.state.layers);
-  }
-  isLayerActiveForFocused(layer, focused) {
-    return isLayerActiveForFocused(this.host, layer, focused);
-  }
-  layerCanCacheActiveKeys(layer) {
-    return !layer.hasUnkeyedMatchers && !layer.hasUnkeyedCommands && !layer.hasUnkeyedBindings;
-  }
-  activeLayersCanCacheActiveKeys(activeLayers) {
-    for (const layer of activeLayers) {
-      if (!this.layerCanCacheActiveKeys(layer)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  collectNodesFromNode(node) {
-    const nodes = [];
-    let current = node;
-    while (current && current.stroke) {
-      nodes.push(current);
-      current = current.parent;
-    }
-    nodes.reverse();
-    return nodes;
-  }
-  collectSequencePartsFromPending(pending) {
-    const focused = this.getFocusedTarget();
-    const activeView = this.catalog.getActiveCommandView(focused);
-    const paths = pending.captures.map((capture) => this.collectNodesFromNode(capture.node));
-    const firstPath = paths[0];
-    if (!firstPath || firstPath.length === 0) {
-      return [];
-    }
-    const parts = [];
-    for (let index = 0;index < firstPath.length; index += 1) {
-      const firstNode = firstPath[index];
-      if (!firstNode?.stroke || firstNode.match === null) {
-        continue;
-      }
-      let display;
-      let tokenName;
-      let hasDisplayConflict = false;
-      let hasTokenConflict = false;
-      for (const path of paths) {
-        const node = path[index];
-        if (!node) {
-          continue;
-        }
-        const presentation = this.getNodePresentation(node, focused, activeView);
-        if (display === undefined) {
-          display = presentation.display;
-          tokenName = presentation.tokenName;
-          continue;
-        }
-        if (!hasDisplayConflict && display !== presentation.display) {
-          hasDisplayConflict = true;
-        }
-        if (!hasTokenConflict && tokenName !== presentation.tokenName) {
-          hasTokenConflict = true;
-        }
-      }
-      if (display === undefined || hasDisplayConflict) {
-        display = stringifyKeyStroke(firstNode.stroke);
-      }
-      if (hasTokenConflict) {
-        tokenName = undefined;
-      }
-      parts.push(createKeySequencePart(firstNode.stroke, {
-        display,
-        match: firstNode.match,
-        tokenName
-      }));
-    }
-    return parts;
-  }
-  collectMatchingBindings(bindings, focused, activeView) {
-    const matches = [];
-    for (const binding of bindings) {
-      if (this.conditions.matchesConditions(binding) && this.catalog.isBindingVisible(binding, focused, activeView)) {
-        matches.push(binding);
-      }
-    }
-    return matches;
-  }
-  hasMatchingBindings(bindings, focused, activeView) {
-    for (const binding of bindings) {
-      if (this.conditions.matchesConditions(binding) && this.catalog.isBindingVisible(binding, focused, activeView)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  getNodePresentation(node, focused, activeView, reachableBindings = this.collectMatchingBindings(node.reachableBindings, focused, activeView)) {
-    if (!node.stroke) {
-      return { display: "" };
-    }
-    const partIndex = node.depth - 1;
-    let display;
-    let tokenName;
-    let hasDisplayConflict = false;
-    let hasTokenConflict = false;
-    for (const binding of reachableBindings) {
-      const part = binding.sequence[partIndex];
-      if (!part) {
-        continue;
-      }
-      if (display === undefined) {
-        display = part.display;
-        tokenName = part.tokenName;
-        continue;
-      }
-      if (!hasDisplayConflict && display !== part.display) {
-        hasDisplayConflict = true;
-      }
-      if (!hasTokenConflict && tokenName !== part.tokenName) {
-        hasTokenConflict = true;
-      }
-    }
-    if (display === undefined || hasDisplayConflict) {
-      display = stringifyKeyStroke(node.stroke);
-    }
-    if (hasTokenConflict) {
-      tokenName = undefined;
-    }
-    return {
-      display,
-      tokenName
-    };
-  }
-  toActiveBinding(binding, focused, activeView) {
-    return {
-      sequence: binding.sequence,
-      command: binding.command,
-      commandAttrs: this.catalog.getBindingCommandAttrs(binding, focused, activeView),
-      attrs: binding.attrs,
-      event: binding.event,
-      preventDefault: binding.preventDefault,
-      fallthrough: binding.fallthrough
-    };
-  }
-  collectActiveBindings(bindings, focused, activeView) {
-    return bindings.map((binding) => this.toActiveBinding(binding, focused, activeView));
-  }
-  collectActiveKeysAtRoot(activeLayers, includeBindings, includeMetadata, focused, activeView) {
-    const activeKeys = new Map;
-    const stopped = new Set;
-    const hasLayerConditions = this.state.layers.layersWithConditions > 0;
-    for (const layer of activeLayers) {
-      if (layer.root.children.size === 0) {
-        continue;
-      }
-      if (hasLayerConditions && !this.conditions.hasNoConditions(layer) && !this.conditions.matchesConditions(layer)) {
-        continue;
-      }
-      for (const [bindingKey, child] of layer.root.children) {
-        if (stopped.has(bindingKey)) {
-          continue;
-        }
-        const selection = this.selectActiveKey(child, includeBindings, focused, activeView);
-        if (!selection) {
-          continue;
-        }
-        const existing = activeKeys.get(bindingKey);
-        if (!existing) {
-          activeKeys.set(bindingKey, this.createActiveKeyState(child.stroke, selection, includeBindings));
-        } else {
-          this.updateActiveKeyState(existing, selection, includeBindings);
-        }
-        if (selection.stop) {
-          stopped.add(bindingKey);
-        }
-      }
-    }
-    const materialized = [];
-    for (const state of activeKeys.values()) {
-      const activeKey = this.materializeActiveKey(state, includeBindings, includeMetadata, focused, activeView);
-      if (activeKey) {
-        materialized.push(activeKey);
-      }
-    }
-    return materialized;
-  }
-  collectActiveKeysFromPending(captures, includeBindings, includeMetadata, focused, activeView) {
-    const activeKeys = new Map;
-    const stopped = new Set;
-    for (const capture of captures) {
-      for (const [bindingKey, child] of capture.node.children) {
-        if (stopped.has(bindingKey)) {
-          continue;
-        }
-        const selection = this.selectActiveKey(child, includeBindings, focused, activeView);
-        if (!selection) {
-          continue;
-        }
-        const existing = activeKeys.get(bindingKey);
-        if (!existing) {
-          activeKeys.set(bindingKey, this.createActiveKeyState(child.stroke, selection, includeBindings));
-        } else {
-          this.updateActiveKeyState(existing, selection, includeBindings);
-        }
-        if (selection.stop) {
-          stopped.add(bindingKey);
-        }
-      }
-    }
-    const materialized = [];
-    for (const state of activeKeys.values()) {
-      const activeKey = this.materializeActiveKey(state, includeBindings, includeMetadata, focused, activeView);
-      if (activeKey) {
-        materialized.push(activeKey);
-      }
-    }
-    return materialized;
-  }
-  selectActiveKey(node, includeBindings, focused, activeView) {
-    return node.children.size > 0 ? this.selectPrefixActiveKey(node, includeBindings, focused, activeView) : this.selectExactActiveKey(node, includeBindings, focused, activeView);
-  }
-  selectPrefixActiveKey(node, includeBindings, focused, activeView) {
-    if (!node.stroke) {
-      return;
-    }
-    const reachableBindings = this.collectMatchingBindings(node.reachableBindings, focused, activeView);
-    if (reachableBindings.length === 0) {
-      return;
-    }
-    const prefixBindings = this.selectActiveBindings(node.bindings, focused, activeView);
-    return {
-      ...this.getNodePresentation(node, focused, activeView, reachableBindings),
-      continues: true,
-      firstBinding: prefixBindings?.bindings[0],
-      commandBinding: prefixBindings?.commandBinding,
-      bindings: includeBindings && prefixBindings && prefixBindings.bindings.length > 0 ? [...prefixBindings.bindings] : undefined,
-      stop: true
-    };
-  }
-  selectExactActiveKey(node, includeBindings, focused, activeView) {
-    if (!node.stroke) {
-      return;
-    }
-    const selected = this.selectActiveBindings(node.bindings, focused, activeView);
-    if (!selected) {
-      return;
-    }
-    let display;
-    let tokenName;
-    if (selected.bindings.length === 1) {
-      const part = selected.bindings[0]?.sequence[node.depth - 1];
-      display = part?.display ?? stringifyKeyStroke(node.stroke);
-      tokenName = part?.tokenName;
-    } else {
-      const presentation = this.getNodePresentation(node, focused, activeView, selected.bindings);
-      display = presentation.display;
-      tokenName = presentation.tokenName;
-    }
-    return {
-      display,
-      tokenName,
-      continues: false,
-      firstBinding: selected.bindings[0],
-      commandBinding: selected.commandBinding,
-      bindings: includeBindings ? [...selected.bindings] : undefined,
-      stop: selected.stop
-    };
-  }
-  selectActiveBindings(bindings, focused, activeView) {
-    const selected = [];
-    let commandBinding;
-    for (const binding of bindings) {
-      if (!this.conditions.matchesConditions(binding) || !this.catalog.isBindingVisible(binding, focused, activeView)) {
-        continue;
-      }
-      selected.push(binding);
-      if (binding.command === undefined) {
-        continue;
-      }
-      commandBinding ??= binding;
-      if (!binding.fallthrough) {
-        return { bindings: selected, commandBinding, stop: true };
-      }
-    }
-    if (selected.length === 0) {
-      return;
-    }
-    return { bindings: selected, commandBinding, stop: false };
-  }
-  createActiveKeyState(stroke, selection, includeBindings) {
-    return {
-      stroke,
-      display: selection.display,
-      tokenName: selection.tokenName,
-      continues: selection.continues,
-      firstBinding: selection.firstBinding,
-      commandBinding: selection.commandBinding,
-      bindings: includeBindings && selection.bindings ? [...selection.bindings] : undefined
-    };
-  }
-  updateActiveKeyState(state, selection, includeBindings) {
-    if (!state.firstBinding && selection.firstBinding) {
-      state.firstBinding = selection.firstBinding;
-    }
-    if (!state.commandBinding && selection.commandBinding) {
-      state.commandBinding = selection.commandBinding;
-    }
-    if (selection.continues) {
-      state.continues = true;
-    }
-    if (!includeBindings || !selection.bindings || selection.bindings.length === 0) {
-      return;
-    }
-    if (!state.bindings) {
-      state.bindings = [...selection.bindings];
-      return;
-    }
-    state.bindings.push(...selection.bindings);
-  }
-  materializeActiveKey(state, includeBindings, includeMetadata, focused, activeView) {
-    if (!state.commandBinding && !state.continues) {
-      return;
-    }
-    const activeKey = {
-      stroke: cloneKeyStroke(state.stroke),
-      display: state.display,
-      continues: state.continues
-    };
-    if (state.tokenName) {
-      activeKey.tokenName = state.tokenName;
-    }
-    if (state.commandBinding) {
-      activeKey.command = state.commandBinding.command;
-    }
-    if (includeBindings && state.bindings && state.bindings.length > 0) {
-      activeKey.bindings = state.bindings.length === 1 ? [this.toActiveBinding(state.bindings[0], focused, activeView)] : this.collectActiveBindings(state.bindings, focused, activeView);
-    }
-    if (includeMetadata) {
-      if (state.firstBinding?.attrs) {
-        activeKey.bindingAttrs = state.firstBinding.attrs;
-      }
-      const commandAttrs = state.commandBinding ? this.catalog.getBindingCommandAttrs(state.commandBinding, focused, activeView) : undefined;
-      if (commandAttrs) {
-        activeKey.commandAttrs = commandAttrs;
-      }
-    }
-    return activeKey;
-  }
-  invalidateCaches() {
-    this.state.projection.pendingSequenceCacheVersion = -1;
-    this.state.projection.activeKeysPlainCacheVersion = -1;
-    this.state.projection.activeKeysBindingsCacheVersion = -1;
-    this.state.projection.activeKeysMetadataCacheVersion = -1;
-    this.state.projection.activeKeysBindingsAndMetadataCacheVersion = -1;
-  }
-  notifyPendingSequenceChange() {
-    if (!this.hooks.has("pendingSequence")) {
-      return;
-    }
-    this.hooks.emit("pendingSequence", this.state.projection.pendingSequence ? this.collectSequencePartsFromPending(this.state.projection.pendingSequence) : []);
-  }
-}
-
-// src/schema.ts
-var RESERVED_COMMAND_FIELDS = new Set(["name", "run"]);
-var RESERVED_BINDING_FIELDS = new Set(["key", "cmd", "event", "preventDefault", "fallthrough"]);
-var RESERVED_LAYER_FIELDS = new Set(["target", "targetMode", "priority", "bindings", "commands"]);
-
-// src/services/primitives/field-invariants.ts
-function mergeRequirement(target, name, value, source) {
-  if (Object.prototype.hasOwnProperty.call(target, name) && !Object.is(target[name], value)) {
-    throw new Error(`Conflicting keymap requirement for "${name}" from ${source}`);
-  }
-  target[name] = value;
-}
-function mergeAttribute(target, name, value, source) {
-  if (Object.prototype.hasOwnProperty.call(target, name) && !Object.is(target[name], value)) {
-    throw new Error(`Conflicting keymap attribute for "${name}" from ${source}`);
-  }
-  target[name] = value;
-}
-
-// src/services/values.ts
-function isPlainObject(value) {
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function getErrorMessage(error, fallback) {
-  if (error instanceof Error && error.message) {
-    return error.message;
-  }
-  return fallback;
-}
-function isPromiseLike(value) {
-  if (!value) {
-    return false;
-  }
-  if (typeof value !== "object" && typeof value !== "function") {
-    return false;
-  }
-  return typeof value.then === "function";
-}
-function snapshotDataValue(value, options) {
-  const deep = options?.deep === true;
-  const freeze = options?.freeze === true;
-  const preserveNonPlainObjects = options?.preserveNonPlainObjects === true;
-  if (Array.isArray(value)) {
-    const cloned = deep ? value.map((entry) => snapshotDataValue(entry, options)) : [...value];
-    return freeze ? Object.freeze(cloned) : cloned;
-  }
-  if (value && typeof value === "object") {
-    if (preserveNonPlainObjects && !isPlainObject(value)) {
-      return value;
-    }
-    const cloned = {};
-    for (const [key, entry] of Object.entries(value)) {
-      cloned[key] = deep ? snapshotDataValue(entry, options) : entry;
-    }
-    return freeze ? Object.freeze(cloned) : cloned;
-  }
-  return value;
-}
-
-// src/services/command-catalog.ts
-var DEFAULT_COMMAND_SEARCH_FIELDS = ["name"];
-var SNAPSHOT_COMMAND_METADATA_OPTIONS = Object.freeze({
-  deep: true,
-  preserveNonPlainObjects: true
-});
-var SNAPSHOT_FROZEN_COMMAND_METADATA_OPTIONS = Object.freeze({
-  deep: true,
-  freeze: true,
-  preserveNonPlainObjects: true
-});
-var EMPTY_COMMAND_FIELDS = Object.freeze({});
-function createCommandChainCacheState() {
-  return {
-    resolvedWithoutRecordChains: new Map,
-    resolvedWithRecordChains: new Map,
-    fallbackWithoutRecord: new Map,
-    fallbackWithRecord: new Map,
-    fallbackWithoutRecordErrors: new Set,
-    fallbackWithRecordErrors: new Set
-  };
-}
-function normalizeBindingCommand(command) {
-  if (command === undefined || typeof command === "function") {
-    return command;
-  }
-  const trimmed = command.trim();
-  if (!trimmed) {
-    throw new Error("Invalid keymap command: command cannot be empty");
-  }
-  return trimmed;
-}
-function normalizeCommandName(name) {
-  const trimmed = name.trim();
-  if (!trimmed) {
-    throw new Error("Invalid keymap command name: name cannot be empty");
-  }
-  if (/\s/.test(trimmed)) {
-    throw new Error(`Invalid keymap command name "${name}": command names cannot contain whitespace`);
-  }
-  return trimmed;
-}
-
-class CommandCatalogService {
-  state;
-  host;
-  notify;
-  conditions;
-  options;
-  constructor(state, host, notify, conditions, options) {
-    this.state = state;
-    this.host = host;
-    this.notify = notify;
-    this.conditions = conditions;
-    this.options = options;
-  }
-  normalizeCommands(commands) {
-    return normalizeRegisteredCommands({
-      commands,
-      commandFields: this.state.environment.commandFields,
-      conditions: this.conditions,
-      onError: (code, error, message) => {
-        this.notify.emitError(code, error, message);
-      }
-    });
-  }
-  prependCommandResolver(resolver) {
-    return this.mutateCommandResolvers(() => this.state.commands.commandResolvers.prepend(resolver), resolver);
-  }
-  appendCommandResolver(resolver) {
-    return this.mutateCommandResolvers(() => this.state.commands.commandResolvers.append(resolver), resolver);
-  }
-  clearCommandResolvers() {
-    if (!this.state.commands.commandResolvers.has()) {
-      return;
-    }
-    this.notify.runWithStateChangeBatch(() => {
-      this.state.commands.commandResolvers.clear();
-      this.state.commands.commandMetadataVersion += 1;
-      this.options.onCommandResolversChanged();
-      this.notify.queueStateChange();
-    });
-  }
-  getCommands(query) {
-    return this.getFilteredCommandEntries(query).map((entry) => getRegisteredCommandRecord(entry.command));
-  }
-  getCommandEntries(query) {
-    const context = this.getCommandQueryContext(query);
-    const filteredEntries = this.getFilteredCommandEntries(query, context);
-    if (filteredEntries.length === 0) {
-      return [];
-    }
-    const grouped = filteredEntries.map((entry) => ({
-      entry,
-      command: getRegisteredCommandRecord(entry.command),
-      bindings: []
-    }));
-    const indexesByName = new Map;
-    for (const [index, item] of grouped.entries()) {
-      const existing = indexesByName.get(item.command.name);
-      if (existing) {
-        existing.push(index);
-      } else {
-        indexesByName.set(item.command.name, [index]);
-      }
-    }
-    if (indexesByName.size > 0) {
-      this.collectCommandEntryBindings(grouped, indexesByName, context);
-    }
-    return grouped.map((item) => ({
-      command: item.command,
-      bindings: item.bindings
-    }));
-  }
-  getResolvedCommandChain(command, focused, includeRecord) {
-    const view = this.getActiveCommandView(focused);
-    const entries = this.getResolvedCommandChainFromView(view, command, focused, includeRecord, "active", view.chainsByName.get(command));
-    const hadError = (includeRecord ? view.fallbackWithRecordErrors : view.fallbackWithoutRecordErrors).has(command);
-    return { entries, hadError };
-  }
-  getRegisteredResolvedEntries(command, includeRecord) {
-    const view = this.getRegisteredCommandView();
-    const cache = includeRecord ? view.resolvedWithRecordChains : view.resolvedWithoutRecordChains;
-    const cached = cache.get(command);
-    if (cached) {
-      return cached.length > 0 ? cached : undefined;
-    }
-    const chain = view.chainsByName.get(command);
-    if (!chain || chain.length === 0) {
-      cache.set(command, []);
-      return;
-    }
-    const resolved = [];
-    for (const entry of chain) {
-      resolved.push({
-        target: entry.layer.target,
-        resolved: resolveRegisteredCommand(entry.command, { includeRecord })
-      });
-    }
-    cache.set(command, resolved);
-    return resolved;
-  }
-  getRegisteredResolverFallback(command, includeRecord) {
-    const view = this.getRegisteredCommandView();
-    const fallback = this.getFallbackResolvedCommand(view, command, null, includeRecord, "registered");
-    const hadError = (includeRecord ? view.fallbackWithRecordErrors : view.fallbackWithoutRecordErrors).has(command);
-    return {
-      resolved: fallback?.resolved,
-      hadError
-    };
-  }
-  getCommandAttrs(command, focused) {
-    const top = this.getTopResolvedCommand(command, focused, false);
-    return top?.resolved.attrs;
-  }
-  getTopCommandRecord(command, focused) {
-    const top = this.getTopResolvedCommand(command, focused, true);
-    return top?.resolved.record;
-  }
-  getTopRegisteredCommandRecord(command) {
-    const top = this.getTopRegisteredCommand(command);
-    return top ? getRegisteredCommandRecord(top.command) : undefined;
-  }
-  getDispatchUnavailableCommandState(command, focused, includeRecord) {
-    const view = this.getRegisteredCommandView();
-    const chain = view.chainsByName.get(command);
-    if (!chain || chain.length === 0) {
-      return;
-    }
-    let inactiveEntry;
-    let disabledEntry;
-    for (const entry of chain) {
-      if (!isLayerActiveForFocused(this.host, entry.layer, focused)) {
-        inactiveEntry ??= entry;
-        continue;
-      }
-      if (!this.conditions.layerMatchesRuntimeState(entry.layer) || !this.conditions.matchesConditions(entry.command)) {
-        disabledEntry ??= entry;
-      }
-    }
-    const unavailableEntry = disabledEntry ?? inactiveEntry;
-    if (!unavailableEntry) {
-      return;
-    }
-    return {
-      reason: disabledEntry ? "disabled" : "inactive",
-      command: includeRecord ? getRegisteredCommandRecord(unavailableEntry.command) : undefined
-    };
-  }
-  getActiveCommandView(focused) {
-    const currentFocused = getFocusedTargetIfAvailable(this.host);
-    const derivedStateVersion = this.state.notify.derivedStateVersion;
-    if (focused === currentFocused && this.state.commands.activeCommandViewVersion === derivedStateVersion && this.state.commands.activeCommandView?.cacheable) {
-      return this.state.commands.activeCommandView;
-    }
-    const entries = [];
-    const reachable = [];
-    const reachableByName = new Map;
-    const chainsByName = new Map;
-    let cacheable = true;
-    if (this.state.layers.layersWithCommands > 0) {
-      for (const layer of getActiveLayersForFocused(this.state.layers, this.host, focused)) {
-        if (layer.commands.length === 0 || !this.conditions.layerMatchesRuntimeState(layer)) {
-          continue;
-        }
-        if (layer.hasUnkeyedMatchers) {
-          cacheable = false;
-        }
-        for (const command of layer.commands) {
-          if (command.hasUnkeyedMatchers) {
-            cacheable = false;
-          }
-          if (!this.conditions.matchesConditions(command)) {
-            continue;
-          }
-          const entry = { layer, command };
-          entries.push(entry);
-          const existing = chainsByName.get(command.name);
-          if (existing) {
-            existing.push(entry);
-          } else {
-            chainsByName.set(command.name, [entry]);
-          }
-          if (!reachableByName.has(command.name)) {
-            reachableByName.set(command.name, entry);
-            reachable.push(entry);
-          }
-        }
-      }
-    }
-    const view = {
-      cacheable,
-      entries,
-      reachable,
-      reachableByName,
-      chainsByName,
-      ...createCommandChainCacheState()
-    };
-    if (focused === currentFocused && view.cacheable) {
-      this.state.commands.activeCommandViewVersion = derivedStateVersion;
-      this.state.commands.activeCommandView = view;
-    }
-    return view;
-  }
-  getRegisteredCommandView() {
-    const cacheVersion = this.state.commands.commandMetadataVersion;
-    if (this.state.commands.registeredCommandViewVersion === cacheVersion && this.state.commands.registeredCommandView) {
-      return this.state.commands.registeredCommandView;
-    }
-    const entries = [];
-    const chainsByName = new Map;
-    for (const layer of this.state.layers.sortedLayers) {
-      if (layer.commands.length === 0) {
-        continue;
-      }
-      for (const command of layer.commands) {
-        const entry = { layer, command };
-        entries.push(entry);
-        const existing = chainsByName.get(command.name);
-        if (existing) {
-          existing.push(entry);
-        } else {
-          chainsByName.set(command.name, [entry]);
-        }
-      }
-    }
-    const view = {
-      entries,
-      chainsByName,
-      ...createCommandChainCacheState()
-    };
-    this.state.commands.registeredCommandViewVersion = cacheVersion;
-    this.state.commands.registeredCommandView = view;
-    return view;
-  }
-  isBindingVisible(binding, focused, activeView) {
-    if (binding.command === undefined || binding.run) {
-      return true;
-    }
-    if (typeof binding.command !== "string") {
-      return false;
-    }
-    if (activeView.reachableByName.has(binding.command)) {
-      return true;
-    }
-    return this.getFallbackResolvedCommand(activeView, binding.command, focused, false, "active") !== undefined;
-  }
-  getBindingCommandAttrs(binding, focused, activeView) {
-    if (typeof binding.command !== "string") {
-      return;
-    }
-    const active = activeView.reachableByName.get(binding.command);
-    if (active) {
-      return active.command.attrs;
-    }
-    const fallback = this.getFallbackResolvedCommand(activeView, binding.command, focused, false, "active");
-    return fallback?.resolved.attrs;
-  }
-  getCommandResolutionStatus(command, layerCommands) {
-    if (layerCommands?.has(command) || this.state.commands.registeredNames.has(command)) {
-      return "resolved";
-    }
-    const lookup = this.resolveCommandWithResolvers(command, getFocusedTargetIfAvailable(this.host));
-    if (lookup.resolved || lookup.hadError) {
-      return lookup.resolved ? "resolved" : "error";
-    }
-    return "unresolved";
-  }
-  mutateCommandResolvers(register, resolver) {
-    return this.notify.runWithStateChangeBatch(() => {
-      const off = register();
-      this.state.commands.commandMetadataVersion += 1;
-      this.options.onCommandResolversChanged();
-      this.notify.queueStateChange();
-      return () => {
-        this.notify.runWithStateChangeBatch(() => {
-          off();
-          if (this.state.commands.commandResolvers.values().includes(resolver)) {
-            return;
-          }
-          this.state.commands.commandMetadataVersion += 1;
-          this.options.onCommandResolversChanged();
-          this.notify.queueStateChange();
-        });
-      };
-    });
-  }
-  getTopResolvedCommand(command, focused, includeRecord) {
-    const activeView = this.getActiveCommandView(focused);
-    const active = activeView.reachableByName.get(command);
-    if (active) {
-      return {
-        target: active.layer.target,
-        resolved: resolveRegisteredCommand(active.command, { includeRecord })
-      };
-    }
-    return this.getFallbackResolvedCommand(activeView, command, focused, includeRecord, "active");
-  }
-  getTopRegisteredCommand(command) {
-    const view = this.getRegisteredCommandView();
-    return view.chainsByName.get(command)?.[0];
-  }
-  getFallbackResolvedCommand(view, command, focused, includeRecord, mode) {
-    const cache = includeRecord ? view.fallbackWithRecord : view.fallbackWithoutRecord;
-    const errorCache = includeRecord ? view.fallbackWithRecordErrors : view.fallbackWithoutRecordErrors;
-    if (cache.has(command)) {
-      const cached = cache.get(command);
-      return cached ? { resolved: cached } : undefined;
-    }
-    const lookup = this.resolveCommandWithResolvers(command, focused, { includeRecord, mode });
-    cache.set(command, lookup.resolved ?? null);
-    if (lookup.hadError) {
-      errorCache.add(command);
-    }
-    if (!lookup.resolved) {
-      return;
-    }
-    return { resolved: lookup.resolved };
-  }
-  getResolvedCommandChainFromView(view, command, focused, includeRecord, mode, activeChain) {
-    const cache = includeRecord ? view.resolvedWithRecordChains : view.resolvedWithoutRecordChains;
-    const cached = cache.get(command);
-    if (cached) {
-      return cached.length > 0 ? cached : undefined;
-    }
-    const resolved = [];
-    const chain = activeChain;
-    if (chain) {
-      for (const entry of chain) {
-        resolved.push({
-          target: entry.layer.target,
-          resolved: resolveRegisteredCommand(entry.command, { includeRecord })
-        });
-      }
-    }
-    const fallback = this.getFallbackResolvedCommand(view, command, focused, includeRecord, mode);
-    if (fallback) {
-      resolved.push(fallback);
-    }
-    cache.set(command, resolved);
-    return resolved.length > 0 ? resolved : undefined;
-  }
-  getRegisteredLayerCommandEntries() {
-    const cacheVersion = this.state.commands.commandMetadataVersion;
-    if (this.state.commands.registeredCommandEntriesCacheVersion === cacheVersion) {
-      return this.state.commands.registeredCommandEntriesCache;
-    }
-    const layers = [...this.state.layers.layers];
-    layers.sort((left, right) => left.order - right.order);
-    const entries = [];
-    for (const layer of layers) {
-      for (const command of layer.commands) {
-        entries.push({ layer, command });
-      }
-    }
-    this.state.commands.registeredCommandEntriesCacheVersion = cacheVersion;
-    this.state.commands.registeredCommandEntriesCache = entries;
-    return entries;
-  }
-  getCommandQueryContext(query) {
-    const visibility = query?.visibility ?? "reachable";
-    const focused = query && Object.prototype.hasOwnProperty.call(query, "focused") ? query.focused ?? null : getFocusedTargetIfAvailable(this.host);
-    if (visibility === "registered") {
-      return { visibility, focused };
-    }
-    return {
-      visibility,
-      focused,
-      activeView: this.getActiveCommandView(focused)
-    };
-  }
-  getFilteredCommandEntries(query, context = this.getCommandQueryContext(query)) {
-    let entries;
-    if (context.visibility === "registered") {
-      entries = this.getRegisteredLayerCommandEntries();
-    } else if (context.visibility === "active") {
-      entries = context.activeView?.entries ?? [];
-    } else {
-      entries = context.activeView?.reachable ?? [];
-    }
-    return queryLayerCommandEntries({
-      entries,
-      query,
-      getCommandRecord: (command) => getRegisteredCommandRecord(command),
-      onFilterError: (error) => {
-        this.notify.emitError("command-query-filter-error", error, "[Keymap] Error in command query filter:");
-      }
-    });
-  }
-  collectCommandEntryBindings(grouped, indexesByName, context) {
-    if (context.visibility === "registered") {
-      const layers = [...this.state.layers.layers];
-      layers.sort((left, right) => left.order - right.order);
-      for (const layer of layers) {
-        for (const binding of layer.compiledBindings) {
-          this.collectBindingForCommandEntries(grouped, indexesByName, binding);
-        }
-      }
-      return;
-    }
-    const activeView = context.activeView;
-    if (!activeView) {
-      return;
-    }
-    for (const layer of getActiveLayersForFocused(this.state.layers, this.host, context.focused)) {
-      if (layer.compiledBindings.length === 0 || !this.conditions.layerMatchesRuntimeState(layer)) {
-        continue;
-      }
-      for (const binding of layer.compiledBindings) {
-        if (!this.conditions.matchesConditions(binding) || !this.isBindingVisible(binding, context.focused, activeView)) {
-          continue;
-        }
-        this.collectBindingForCommandEntries(grouped, indexesByName, binding);
-      }
-    }
-  }
-  collectBindingForCommandEntries(grouped, indexesByName, binding) {
-    if (typeof binding.command !== "string") {
-      return;
-    }
-    const indexes = indexesByName.get(binding.command);
-    if (!indexes || indexes.length === 0) {
-      return;
-    }
-    for (const index of indexes) {
-      const item = grouped[index];
-      if (!item) {
-        continue;
-      }
-      item.bindings.push({
-        sequence: binding.sequence,
-        command: binding.command,
-        commandAttrs: item.command.attrs,
-        attrs: binding.attrs,
-        event: binding.event,
-        preventDefault: binding.preventDefault,
-        fallthrough: binding.fallthrough
-      });
-    }
-  }
-  resolveCommandWithResolvers(command, focused, options) {
-    const includeRecord = options?.includeRecord === true;
-    const context = this.createCommandResolverContext(includeRecord, focused, options?.mode ?? "active");
-    return resolveCommandWithResolvers(command, this.state.commands.commandResolvers.values(), context, (error) => {
-      this.notify.emitError("command-resolver-error", error, `[Keymap] Error in command resolver for "${command}":`);
-    });
-  }
-  createCommandResolverContext(includeRecord, focused, mode) {
-    return {
-      getCommandAttrs: (name) => {
-        if (mode === "registered") {
-          return this.getTopRegisteredCommand(name)?.command.attrs;
-        }
-        return this.getCommandAttrs(name, focused);
-      },
-      getCommandRecord: (name) => {
-        if (!includeRecord) {
-          return;
-        }
-        if (mode === "registered") {
-          return this.getTopRegisteredCommandRecord(name);
-        }
-        return this.getTopCommandRecord(name, focused);
-      }
-    };
-  }
-}
-function getRegisteredCommandRecord(command) {
-  if (command.record) {
-    return command.record;
-  }
-  let fields = EMPTY_COMMAND_FIELDS;
-  if (command.fields !== EMPTY_COMMAND_FIELDS && Object.keys(command.fields).length > 0) {
-    fields = snapshotDataValue(command.fields, SNAPSHOT_FROZEN_COMMAND_METADATA_OPTIONS);
-  }
-  const record = command.attrs ? Object.freeze({
-    name: command.name,
-    fields,
-    attrs: snapshotDataValue(command.attrs, SNAPSHOT_FROZEN_COMMAND_METADATA_OPTIONS)
-  }) : Object.freeze({
-    name: command.name,
-    fields
-  });
-  command.record = record;
-  return record;
-}
-function resolveRegisteredCommand(command, options) {
-  const includeRecord = options?.includeRecord === true;
-  if (includeRecord) {
-    const existing2 = command.resolvedWithRecord;
-    if (existing2) {
-      return existing2;
-    }
-    const resolved2 = {
-      run: createRegisteredCommandRunner(command)
-    };
-    if (command.attrs) {
-      resolved2.attrs = command.attrs;
-    }
-    resolved2.record = getRegisteredCommandRecord(command);
-    command.resolvedWithRecord = resolved2;
-    return resolved2;
-  }
-  const existing = command.resolved;
-  if (existing) {
-    return existing;
-  }
-  const resolved = {
-    run: createRegisteredCommandRunner(command)
-  };
-  if (command.attrs) {
-    resolved.attrs = command.attrs;
-  }
-  command.resolved = resolved;
-  return resolved;
-}
-function normalizeRegisteredCommands(options) {
-  const normalizedCommands = [];
-  const seen = new Set;
-  for (const command of options.commands) {
-    let normalizedCommand;
-    try {
-      const mergedAttrs = {};
-      const mergedFields = {};
-      const mergedRequires = {};
-      const matchers = [];
-      const conditionKeys = new Set;
-      let hasUnkeyedMatchers = false;
-      const normalizedName = normalizeCommandName(command.name);
-      if (seen.has(normalizedName)) {
-        options.onError("duplicate-command", { command: normalizedName }, `Duplicate keymap command "${normalizedName}" in the same layer`);
-        continue;
-      }
-      for (const [fieldName, value] of Object.entries(command)) {
-        if (RESERVED_COMMAND_FIELDS.has(fieldName) || value === undefined) {
-          continue;
-        }
-        mergedFields[fieldName] = snapshotDataValue(value, SNAPSHOT_COMMAND_METADATA_OPTIONS);
-        const compiler = options.commandFields.get(fieldName);
-        if (!compiler) {
-          continue;
-        }
-        compiler(value, createCommandFieldContext(mergedAttrs, mergedRequires, conditionKeys, matchers, options.conditions, fieldName, {
-          onUnkeyedMatcher() {
-            hasUnkeyedMatchers = true;
-          }
-        }));
-      }
-      const attrs = Object.keys(mergedAttrs).length === 0 ? undefined : Object.freeze(mergedAttrs);
-      const fields = Object.keys(mergedFields).length === 0 ? EMPTY_COMMAND_FIELDS : Object.freeze(mergedFields);
-      normalizedCommand = {
-        name: normalizedName,
-        fields,
-        run: command.run,
-        requires: Object.entries(mergedRequires),
-        matchers,
-        conditionKeys: [...conditionKeys],
-        hasUnkeyedMatchers,
-        matchCacheDirty: true
-      };
-      if (attrs) {
-        normalizedCommand.attrs = attrs;
-      }
-    } catch (error) {
-      options.onError("register-command-failed", error, getErrorMessage(error, `Failed to register keymap command "${String(command.name)}"`));
-      continue;
-    }
-    seen.add(normalizedCommand.name);
-    normalizedCommands.push(normalizedCommand);
-  }
-  return normalizedCommands;
-}
-function createCommandFieldContext(mergedAttrs, mergedRequires, conditionKeys, matchers, conditions, fieldName, options) {
-  return {
-    require(name, requiredValue) {
-      mergeRequirement(mergedRequires, name, requiredValue, `field ${fieldName}`);
-      conditionKeys.add(name);
-    },
-    attr(name, attributeValue) {
-      mergeAttribute(mergedAttrs, name, snapshotDataValue(attributeValue, SNAPSHOT_COMMAND_METADATA_OPTIONS), `field ${fieldName}`);
-    },
-    activeWhen(matcher) {
-      const runtimeMatcher = conditions.buildRuntimeMatcher(matcher, `field ${fieldName}`);
-      if (!runtimeMatcher.cacheable) {
-        options.onUnkeyedMatcher();
-      }
-      matchers.push(runtimeMatcher);
-    }
-  };
-}
-function createRegisteredCommandRunner(command) {
-  if (command.runner) {
-    return command.runner;
-  }
-  const runner = (ctx) => {
-    return command.run({
-      ...ctx,
-      command: getRegisteredCommandRecord(command)
-    });
-  };
-  command.runner = runner;
-  return runner;
-}
-function resolveCommandWithResolvers(command, resolvers, context, onResolverError) {
-  if (resolvers.length === 0) {
-    return { hadError: false };
-  }
-  let hadError = false;
-  for (const resolver of resolvers) {
-    let resolved;
-    try {
-      resolved = resolver(command, context);
-    } catch (error) {
-      hadError = true;
-      onResolverError(error);
-      continue;
-    }
-    if (resolved) {
-      return { hadError, resolved };
-    }
-  }
-  return { hadError };
-}
-function queryLayerCommandEntries(options) {
-  const namespace = options.query?.namespace;
-  const normalizedSearch = options.query?.search?.trim().toLowerCase() ?? "";
-  let searchKeys = DEFAULT_COMMAND_SEARCH_FIELDS;
-  if (options.query?.searchIn && options.query.searchIn.length > 0) {
-    searchKeys = options.query.searchIn;
-  }
-  const filter = options.query?.filter;
-  let filterEntries;
-  let filterPredicate;
-  if (typeof filter === "function") {
-    filterPredicate = filter;
-  } else if (filter) {
-    filterEntries = Object.entries(filter);
-  }
-  const results = [];
-  for (const entry of options.entries) {
-    const command = entry.command;
-    if (!commandMatchesNamespace(command, namespace)) {
-      continue;
-    }
-    if (!commandMatchesSearch(command, normalizedSearch, searchKeys)) {
-      continue;
-    }
-    if (!commandMatchesFilters(command, filterEntries, options)) {
-      continue;
-    }
-    const record = options.getCommandRecord(command);
-    if (filterPredicate) {
-      let matches = false;
-      try {
-        matches = filterPredicate(record);
-      } catch (error) {
-        options.onFilterError(error);
-        continue;
-      }
-      if (!matches) {
-        continue;
-      }
-    }
-    results.push(entry);
-  }
-  return results;
-}
-function commandMatchesSearch(command, search, searchKeys) {
-  if (!search) {
-    return true;
-  }
-  for (const key of searchKeys) {
-    if (commandKeyMatchesSearch(command, key, search)) {
-      return true;
-    }
-  }
-  return false;
-}
-function commandMatchesNamespace(command, namespace) {
-  if (namespace === undefined) {
-    return true;
-  }
-  if (!Object.prototype.hasOwnProperty.call(command.fields, "namespace")) {
-    return false;
-  }
-  return commandValueMatchesFilter(command.fields.namespace, namespace);
-}
-function commandMatchesFilters(command, filters, options) {
-  if (!filters) {
-    return true;
-  }
-  for (const [key, matcher] of filters) {
-    if (!commandKeyMatchesQuery(command, key, matcher, options)) {
-      return false;
-    }
-  }
-  return true;
-}
-function commandKeyMatchesSearch(command, key, search) {
-  if (key === "name" && commandValueMatchesSearch(command.name, search)) {
-    return true;
-  }
-  if (Object.prototype.hasOwnProperty.call(command.fields, key) && commandValueMatchesSearch(command.fields[key], search)) {
-    return true;
-  }
-  if (command.attrs && Object.prototype.hasOwnProperty.call(command.attrs, key)) {
-    return commandValueMatchesSearch(command.attrs[key], search);
-  }
-  return false;
-}
-function commandKeyMatchesQuery(command, key, matcher, options) {
-  if (typeof matcher === "function") {
-    let record;
-    const getRecord = () => {
-      if (!record) {
-        record = options.getCommandRecord(command);
-      }
-      return record;
-    };
-    let foundValue = false;
-    if (key === "name") {
-      foundValue = true;
-      try {
-        if (matcher(command.name, getRecord())) {
-          return true;
-        }
-      } catch (error) {
-        options.onFilterError(error);
-        return false;
-      }
-    }
-    if (Object.prototype.hasOwnProperty.call(command.fields, key)) {
-      foundValue = true;
-      try {
-        if (matcher(command.fields[key], getRecord())) {
-          return true;
-        }
-      } catch (error) {
-        options.onFilterError(error);
-        return false;
-      }
-    }
-    if (command.attrs && Object.prototype.hasOwnProperty.call(command.attrs, key)) {
-      foundValue = true;
-      try {
-        if (matcher(command.attrs[key], getRecord())) {
-          return true;
-        }
-      } catch (error) {
-        options.onFilterError(error);
-        return false;
-      }
-    }
-    if (!foundValue) {
-      try {
-        return matcher(undefined, getRecord());
-      } catch (error) {
-        options.onFilterError(error);
-        return false;
-      }
-    }
-    return false;
-  }
-  return commandKeyMatchesExact(command, key, matcher);
-}
-function commandKeyMatchesExact(command, key, matcher) {
-  if (key === "name" && commandValueMatchesFilter(command.name, matcher)) {
-    return true;
-  }
-  if (Object.prototype.hasOwnProperty.call(command.fields, key) && commandValueMatchesFilter(command.fields[key], matcher)) {
-    return true;
-  }
-  if (command.attrs && Object.prototype.hasOwnProperty.call(command.attrs, key)) {
-    return commandValueMatchesFilter(command.attrs[key], matcher);
-  }
-  return false;
-}
-function commandValueMatchesFilter(value, matcher) {
-  if (Array.isArray(matcher)) {
-    for (const expected of matcher) {
-      if (commandValueMatchesExact(value, expected)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  return commandValueMatchesExact(value, matcher);
-}
-function commandValueMatchesExact(value, expected) {
-  if (Array.isArray(value)) {
-    for (const entry of value) {
-      if (commandValueMatchesExact(entry, expected)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  return Object.is(value, expected);
-}
-function commandValueMatchesSearch(value, search) {
-  if (Array.isArray(value)) {
-    for (const entry of value) {
-      if (commandValueMatchesSearch(entry, search)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  if (typeof value === "string") {
-    return value.toLowerCase().includes(search);
-  }
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value).toLowerCase().includes(search);
-  }
-  return false;
-}
-
-// src/services/command-executor.ts
-class CommandExecutorService {
-  notify;
-  runtime;
-  activation;
-  catalog;
-  options;
-  constructor(notify, runtime, activation, catalog, options) {
-    this.notify = notify;
-    this.runtime = runtime;
-    this.activation = activation;
-    this.catalog = catalog;
-    this.options = options;
-  }
-  runCommand(cmd, options) {
-    let normalized;
-    try {
-      normalized = normalizeBindingCommand(cmd);
-    } catch {
-      return { ok: false, reason: "invalid-args" };
-    }
-    if (typeof normalized !== "string") {
-      return { ok: false, reason: "not-found" };
-    }
-    const includeRecord = options?.includeCommand === true;
-    const focused = options?.focused ?? this.activation.getFocusedTargetIfAvailable();
-    const event = options?.event ?? this.options.createCommandEvent();
-    const data = this.runtime.getReadonlyData();
-    const chain = this.catalog.getRegisteredResolvedEntries(normalized, includeRecord);
-    let rejectedResult;
-    if (chain?.length === 1) {
-      const [entry] = chain;
-      if (entry) {
-        const execution = this.executeResolvedCommand(normalized, entry.resolved, {
-          keymap: this.options.keymap,
-          event,
-          focused,
-          target: options?.target ?? entry.target ?? null,
-          data
-        });
-        if (execution.status === "handled" || execution.status === "error") {
-          return execution.result;
-        }
-        rejectedResult = execution.result;
-      }
-    } else if (chain) {
-      for (const entry of chain) {
-        const context = {
-          keymap: this.options.keymap,
-          event,
-          focused,
-          target: options?.target ?? entry.target ?? null,
-          data
-        };
-        const execution = this.executeResolvedCommand(normalized, entry.resolved, context);
-        if (execution.status === "handled" || execution.status === "error") {
-          return execution.result;
-        }
-        rejectedResult = execution.result;
-      }
-    }
-    const fallback = this.catalog.getRegisteredResolverFallback(normalized, includeRecord);
-    if (fallback.resolved) {
-      const execution = this.executeResolvedCommand(normalized, fallback.resolved, {
-        keymap: this.options.keymap,
-        event,
-        focused,
-        target: options?.target ?? null,
-        data
-      });
-      if (execution.status === "handled" || execution.status === "error") {
-        return execution.result;
-      }
-      rejectedResult = execution.result;
-    }
-    if (fallback.hadError) {
-      return { ok: false, reason: "error" };
-    }
-    return rejectedResult ?? { ok: false, reason: "not-found" };
-  }
-  dispatchCommand(cmd, options) {
-    let normalized;
-    try {
-      normalized = normalizeBindingCommand(cmd);
-    } catch {
-      return { ok: false, reason: "invalid-args" };
-    }
-    if (typeof normalized !== "string") {
-      return { ok: false, reason: "not-found" };
-    }
-    const includeRecord = options?.includeCommand === true;
-    const focused = options?.focused ?? this.activation.getFocusedTargetIfAvailable();
-    const event = options?.event ?? this.options.createCommandEvent();
-    const data = this.runtime.getReadonlyData();
-    const chainLookup = this.catalog.getResolvedCommandChain(normalized, focused, includeRecord);
-    const chain = chainLookup.entries;
-    let rejectedResult;
-    if (chain?.length === 1) {
-      const [entry] = chain;
-      if (entry) {
-        const execution = this.executeResolvedCommand(normalized, entry.resolved, {
-          keymap: this.options.keymap,
-          event,
-          focused,
-          target: options?.target ?? entry.target ?? null,
-          data
-        });
-        if (execution.status === "handled" || execution.status === "error") {
-          return execution.result;
-        }
-        rejectedResult = execution.result;
-      }
-    } else if (chain) {
-      for (const entry of chain) {
-        const context = {
-          keymap: this.options.keymap,
-          event,
-          focused,
-          target: options?.target ?? entry.target ?? null,
-          data
-        };
-        const execution = this.executeResolvedCommand(normalized, entry.resolved, context);
-        if (execution.status === "handled" || execution.status === "error") {
-          return execution.result;
-        }
-        rejectedResult = execution.result;
-      }
-    }
-    if (chainLookup.hadError) {
-      return { ok: false, reason: "error" };
-    }
-    const unavailable = this.catalog.getDispatchUnavailableCommandState(normalized, focused, includeRecord);
-    if (unavailable) {
-      return unavailable.command ? { ok: false, reason: unavailable.reason, command: unavailable.command } : { ok: false, reason: unavailable.reason };
-    }
-    return rejectedResult ?? { ok: false, reason: "not-found" };
-  }
-  runBinding(bindingLayer, binding, event, focused) {
-    const data = this.runtime.getReadonlyData();
-    if (binding.run) {
-      const result = this.executeResolvedCommand(typeof binding.command === "string" ? binding.command : "<function>", { run: binding.run }, {
-        keymap: this.options.keymap,
-        event,
-        focused,
-        target: bindingLayer.target ?? null,
-        data
-      });
-      if (result.status === "rejected") {
-        return false;
-      }
-      applyBindingEventEffects(binding, event);
-      return true;
-    }
-    if (typeof binding.command !== "string") {
-      return false;
-    }
-    const chain = this.catalog.getResolvedCommandChain(binding.command, focused, false).entries;
-    if (chain?.length === 1) {
-      const [entry] = chain;
-      if (entry) {
-        const execution = this.executeResolvedCommand(binding.command, entry.resolved, {
-          keymap: this.options.keymap,
-          event,
-          focused,
-          target: entry.target ?? bindingLayer.target ?? null,
-          data
-        });
-        if (execution.status === "rejected") {
-          return false;
-        }
-        applyBindingEventEffects(binding, event);
-        return true;
-      }
-    } else if (chain) {
-      for (const entry of chain) {
-        const context = {
-          keymap: this.options.keymap,
-          event,
-          focused,
-          target: entry.target ?? bindingLayer.target ?? null,
-          data
-        };
-        const execution = this.executeResolvedCommand(binding.command, entry.resolved, context);
-        if (execution.status === "rejected") {
-          continue;
-        }
-        applyBindingEventEffects(binding, event);
-        return true;
-      }
-    }
-    return false;
-  }
-  executeResolvedCommand(commandName, resolved, context) {
-    const command = resolved.record;
-    let result;
-    try {
-      result = resolved.run(context);
-    } catch (error) {
-      this.notify.emitError("command-execution-error", error, `[Keymap] Error running command "${commandName}":`);
-      return {
-        status: "error",
-        result: { ok: false, reason: "error", command }
-      };
-    }
-    if (isPromiseLike(result)) {
-      result.catch((error) => {
-        this.notify.emitError("async-command-error", error, `[Keymap] Async error in command "${commandName}":`);
-      });
-      return {
-        status: "handled",
-        result: { ok: true, command }
-      };
-    }
-    if (result === false) {
-      if (resolved.rejectedResult) {
-        return {
-          status: "rejected",
-          result: resolved.rejectedResult
-        };
-      }
-      return {
-        status: "rejected",
-        result: { ok: false, reason: "rejected", command }
-      };
-    }
-    return {
-      status: "handled",
-      result: { ok: true, command }
-    };
-  }
-}
-function applyBindingEventEffects(binding, event) {
-  if (!binding.preventDefault) {
-    return;
-  }
-  event.preventDefault();
-  event.stopPropagation();
-}
-
-// src/services/primitives/binding-inputs.ts
-function normalizeBindingInputs(bindings) {
-  if (Array.isArray(bindings)) {
-    return bindings;
-  }
-  const normalized = [];
-  for (const [key, cmd] of Object.entries(bindings)) {
-    if (typeof cmd !== "string" && typeof cmd !== "function") {
-      throw new Error(`Invalid keymap binding for "${key}": shorthand bindings must map to string or function commands`);
-    }
-    normalized.push({ key, cmd });
-  }
-  return normalized;
-}
-function snapshotBindingInputs(bindings) {
-  return normalizeBindingInputs(bindings).map((binding) => ({
-    ...binding,
-    key: typeof binding.key === "string" ? binding.key : { ...binding.key }
-  }));
-}
-function snapshotParsedBindingInput(binding) {
-  return {
-    ...binding,
-    sequence: cloneKeySequence(binding.sequence)
-  };
-}
-
-// src/services/compiler.ts
-var EMPTY_COMPILE_FIELDS = Object.freeze({});
-var EMPTY_REQUIRES = [];
-var EMPTY_MATCHERS = [];
-var EMPTY_CONDITION_KEYS = [];
-function createSequenceNode(parent, stroke, match) {
-  return {
-    parent,
-    depth: parent ? parent.depth + 1 : 0,
-    stroke,
-    match,
-    children: new Map,
-    bindings: [],
-    reachableBindings: []
-  };
-}
-function snapshotAttributes(attrs) {
-  if (Object.keys(attrs).length === 0) {
-    return;
-  }
-  return snapshotDataValue(attrs, { freeze: true });
-}
-
-class CompilerService {
-  state;
-  notify;
-  conditions;
-  options;
-  constructor(state, notify, conditions, options) {
-    this.state = state;
-    this.notify = notify;
-    this.conditions = conditions;
-    this.options = options;
-  }
-  parseTokenKey(key) {
-    return parseSingleKeyPartWithParsers(key, this.state.environment.bindingParsers.values(), {
-      tokens: this.state.environment.tokens,
-      layer: EMPTY_COMPILE_FIELDS,
-      parseObjectKey: (value, options) => this.parseObjectKeyPart(value, options)
-    });
-  }
-  compileBindings(bindings, tokens, sourceTarget, sourceLayerOrder, compileFields) {
-    const root = createSequenceNode(null, null, null);
-    const compiledBindings = [];
-    let hasTokenBindings = false;
-    const bindingExpanders = this.state.environment.bindingExpanders.values();
-    const bindingParsers = this.state.environment.bindingParsers.values();
-    const bindingFieldCompilers = this.state.environment.bindingFields;
-    const allowExactPrefixAmbiguity = this.state.dispatch.disambiguationResolvers.has();
-    const warnUnknownField = this.options.warnUnknownField;
-    const warnUnknownToken = this.options.warnUnknownToken;
-    const conditions = this.conditions;
-    for (const [bindingIndex, binding] of bindings.entries()) {
-      let expandedBindingKeys;
-      try {
-        expandedBindingKeys = expandBindingInputWithExpanders(binding.key, bindingExpanders, {
-          layer: compileFields
-        });
-      } catch (error) {
-        this.notify.emitError("binding-expand-error", error, getErrorMessage(error, "Failed to expand keymap binding"));
-        continue;
-      }
-      for (const expandedBindingKey of expandedBindingKeys) {
-        let parsed;
-        try {
-          parsed = typeof expandedBindingKey === "string" ? parseBindingSequenceWithParsers(expandedBindingKey, bindingParsers, {
-            tokens,
-            layer: compileFields,
-            parseObjectKey: (value, options) => this.parseObjectKeyPart(value, options)
-          }) : {
-            parts: [this.parseObjectKeyPart(expandedBindingKey)],
-            usedTokens: [],
-            unknownTokens: [],
-            hasTokenBindings: false
-          };
-        } catch (error) {
-          this.notify.emitError("binding-parse-error", error, getErrorMessage(error, "Failed to parse keymap binding"));
-          continue;
-        }
-        const sequence = parsed.parts;
-        hasTokenBindings ||= parsed.hasTokenBindings;
-        for (const tokenName of parsed.unknownTokens) {
-          warnUnknownToken(tokenName, typeof expandedBindingKey === "string" ? expandedBindingKey : String(expandedBindingKey.name));
-        }
-        for (const compiledInput of this.applyBindingTransformers(binding, sequence, tokens, bindingParsers, compileFields)) {
-          try {
-            const event = this.normalizeBindingEvent(compiledInput.event);
-            const compiledSequence = compiledInput.sequence;
-            let mergedRequires;
-            let mergedAttrs;
-            let matchers;
-            let conditionKeys;
-            let hasUnkeyedMatchers = false;
-            for (const fieldName in compiledInput) {
-              if (fieldName === "sequence") {
-                continue;
-              }
-              if (RESERVED_BINDING_FIELDS.has(fieldName)) {
-                continue;
-              }
-              const value = compiledInput[fieldName];
-              if (value === undefined) {
-                continue;
-              }
-              const compiler = bindingFieldCompilers.get(fieldName);
-              if (!compiler) {
-                warnUnknownField("binding", fieldName);
-                continue;
-              }
-              compiler(value, {
-                require(name, requiredValue) {
-                  if (!mergedRequires) {
-                    mergedRequires = {};
-                  }
-                  mergeRequirement(mergedRequires, name, requiredValue, `field ${fieldName}`);
-                  if (!conditionKeys) {
-                    conditionKeys = new Set;
-                  }
-                  conditionKeys.add(name);
-                },
-                attr(name, attributeValue) {
-                  if (!mergedAttrs) {
-                    mergedAttrs = {};
-                  }
-                  mergeAttribute(mergedAttrs, name, attributeValue, `field ${fieldName}`);
-                },
-                activeWhen: (matcher) => {
-                  const runtimeMatcher = conditions.buildRuntimeMatcher(matcher, `field ${fieldName}`);
-                  if (!runtimeMatcher.cacheable) {
-                    hasUnkeyedMatchers = true;
-                  }
-                  if (!matchers) {
-                    matchers = [];
-                  }
-                  matchers.push(runtimeMatcher);
-                }
-              });
-            }
-            const attrs = mergedAttrs ? snapshotAttributes(mergedAttrs) : undefined;
-            const command = normalizeBindingCommand(compiledInput.cmd);
-            const compiledBinding = {
-              sequence: compiledSequence,
-              command,
-              event,
-              sourceBinding: snapshotParsedBindingInput(compiledInput),
-              sourceTarget,
-              sourceLayerOrder,
-              sourceBindingIndex: bindingIndex,
-              requires: mergedRequires ? Object.entries(mergedRequires) : EMPTY_REQUIRES,
-              matchers: matchers ?? EMPTY_MATCHERS,
-              conditionKeys: conditionKeys ? [...conditionKeys] : EMPTY_CONDITION_KEYS,
-              hasUnkeyedMatchers,
-              matchCacheDirty: true,
-              preventDefault: compiledInput.preventDefault !== false,
-              fallthrough: compiledInput.fallthrough ?? false
-            };
-            if (attrs) {
-              compiledBinding.attrs = attrs;
-            }
-            if (typeof command === "function") {
-              compiledBinding.run = command;
-            }
-            if (compiledSequence.length === 0) {
-              continue;
-            }
-            if (event === "release" && compiledSequence.length > 1) {
-              throw new Error("Keymap release bindings only support a single key stroke");
-            }
-            if (event === "press") {
-              this.insertBinding(root, compiledBinding, allowExactPrefixAmbiguity);
-            }
-            compiledBindings.push(compiledBinding);
-          } catch (error) {
-            this.notify.emitError("binding-compile-error", error, getErrorMessage(error, "Failed to compile keymap binding"));
-          }
-        }
-      }
-    }
-    return {
-      root,
-      bindings: compiledBindings,
-      hasTokenBindings
-    };
-  }
-  parseObjectKeyPart(key, options) {
-    return createKeySequencePart(key, options);
-  }
-  normalizeBindingEvent(event) {
-    if (event === undefined || event === "press") {
-      return "press";
-    }
-    if (event === "release") {
-      return "release";
-    }
-    throw new Error(`Invalid keymap binding event "${String(event)}": expected "press" or "release"`);
-  }
-  applyBindingTransformers(binding, sequence, tokens, bindingParsers, compileFields) {
-    const bindingTransformers = this.state.environment.bindingTransformers.values();
-    if (bindingTransformers.length === 0) {
-      return [{ ...binding, sequence: cloneKeySequence(sequence) }];
-    }
-    const parsedBinding = {
-      ...binding,
-      sequence: cloneKeySequence(sequence)
-    };
-    const extraBindings = [];
-    let keepOriginal = true;
-    const layer = compileFields ?? EMPTY_COMPILE_FIELDS;
-    for (const transformer of bindingTransformers) {
-      try {
-        transformer(parsedBinding, {
-          layer,
-          parseKey: (key) => {
-            return parseSingleKeyPartWithParsers(key, bindingParsers, {
-              tokens,
-              layer,
-              parseObjectKey: (value, options) => this.parseObjectKeyPart(value, options)
-            });
-          },
-          add: (nextBinding) => {
-            extraBindings.push(snapshotParsedBindingInput(nextBinding));
-          },
-          skipOriginal: () => {
-            keepOriginal = false;
-          }
-        });
-      } catch (error) {
-        this.notify.emitError("binding-transformer-error", error, "[Keymap] Error in binding transformer:");
-      }
-    }
-    if (!keepOriginal) {
-      return extraBindings;
-    }
-    if (extraBindings.length === 0) {
-      return [parsedBinding];
-    }
-    return [parsedBinding, ...extraBindings];
-  }
-  insertBinding(root, binding, allowExactPrefixAmbiguity) {
-    let node = root;
-    const touchedNodes = [];
-    const createdNodes = [];
-    try {
-      for (const part of binding.sequence) {
-        if (!allowExactPrefixAmbiguity && node.bindings.some((candidate) => candidate.command !== undefined)) {
-          throw new Error("Keymap bindings cannot use the same sequence as both an exact match and a prefix in the same layer");
-        }
-        const bindingKey = part.match;
-        let child = node.children.get(bindingKey);
-        if (!child) {
-          child = createSequenceNode(node, cloneKeySequencePart(part).stroke, part.match);
-          node.children.set(bindingKey, child);
-          createdNodes.push({ parent: node, key: bindingKey });
-        }
-        child.reachableBindings.push(binding);
-        touchedNodes.push(child);
-        node = child;
-      }
-      if (!allowExactPrefixAmbiguity && binding.command !== undefined && node.children.size > 0) {
-        throw new Error("Keymap bindings cannot use the same sequence as both an exact match and a prefix in the same layer");
-      }
-      node.bindings = [...node.bindings, binding];
-    } catch (error) {
-      for (let index = touchedNodes.length - 1;index >= 0; index -= 1) {
-        const touchedNode = touchedNodes[index];
-        if (!touchedNode) {
-          continue;
-        }
-        if (touchedNode.reachableBindings.at(-1) === binding) {
-          touchedNode.reachableBindings.pop();
-          continue;
-        }
-        touchedNode.reachableBindings = touchedNode.reachableBindings.filter((candidate) => candidate !== binding);
-      }
-      for (let index = createdNodes.length - 1;index >= 0; index -= 1) {
-        const createdNode = createdNodes[index];
-        if (!createdNode) {
-          continue;
-        }
-        const child = createdNode.parent.children.get(createdNode.key);
-        if (!child) {
-          continue;
-        }
-        if (child.children.size > 0 || child.reachableBindings.length > 0 || child.bindings.length > 0) {
-          continue;
-        }
-        createdNode.parent.children.delete(createdNode.key);
-      }
-      throw error;
-    }
-  }
-}
-function expandBindingInputWithExpanders(key, expanders, options) {
-  if (typeof key !== "string" || expanders.length === 0) {
-    return [key];
-  }
-  const layer = options?.layer ?? EMPTY_COMPILE_FIELDS;
-  let candidates = [key];
-  for (const expander of expanders) {
-    const nextCandidates = [];
-    for (const input of candidates) {
-      const result = expander({ input, layer });
-      if (!result) {
-        nextCandidates.push(input);
-        continue;
-      }
-      if (result.length === 0) {
-        throw new Error(`Keymap binding expander must return at least one key sequence for "${input}"`);
-      }
-      for (const expandedInput of result) {
-        if (typeof expandedInput !== "string") {
-          throw new Error(`Keymap binding expander must return string key sequences for "${input}"`);
-        }
-        nextCandidates.push(expandedInput);
-      }
-    }
-    candidates = nextCandidates;
-  }
-  return candidates;
-}
-function parseBindingSequenceWithParsers(key, parsers, options) {
-  if (key.length === 0) {
-    throw new Error("Invalid key sequence: sequence cannot be empty");
-  }
-  if (parsers.length === 0) {
-    throw new Error("No keymap binding parsers are registered");
-  }
-  const tokens = options.tokens ?? new Map;
-  const layer = options.layer ?? EMPTY_COMPILE_FIELDS;
-  const parseObjectKey = options.parseObjectKey;
-  const parts = [];
-  const usedTokens = new Set;
-  const unknownTokens = new Set;
-  let index = 0;
-  while (index < key.length) {
-    let matched = false;
-    for (const parser of parsers) {
-      const result = parser({
-        input: key,
-        index,
-        layer,
-        tokens,
-        normalizeTokenName: normalizeBindingTokenName,
-        createMatch: createTextKeyMatch,
-        parseObjectKey
-      });
-      if (!result) {
-        continue;
-      }
-      if (result.nextIndex <= index || result.nextIndex > key.length) {
-        throw new Error(`Keymap binding parser must advance the input for "${key}" at index ${index}`);
-      }
-      parts.push(...result.parts);
-      for (const tokenName of result.usedTokens ?? []) {
-        usedTokens.add(tokenName);
-      }
-      for (const tokenName of result.unknownTokens ?? []) {
-        unknownTokens.add(tokenName);
-      }
-      index = result.nextIndex;
-      matched = true;
-      break;
-    }
-    if (!matched) {
-      throw new Error(`No keymap binding parser handled input at index ${index} in "${key}"`);
-    }
-  }
-  return {
-    parts,
-    usedTokens: [...usedTokens],
-    unknownTokens: [...unknownTokens],
-    hasTokenBindings: usedTokens.size > 0 || unknownTokens.size > 0
-  };
-}
-function parseSingleKeyPartWithParsers(key, parsers, options) {
-  if (typeof key !== "string") {
-    return options.parseObjectKey(key);
-  }
-  const { parts } = parseBindingSequenceWithParsers(key, parsers, options);
-  const [part] = parts;
-  if (!part || parts.length !== 1) {
-    throw new Error(`Invalid key "${String(key)}": expected a single key stroke`);
-  }
-  return part;
-}
-
-// src/services/conditions.ts
-function isReactiveMatcher(value) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.get === "function" && typeof candidate.subscribe === "function";
-}
-
-class ConditionService {
-  state;
-  notify;
-  constructor(state, notify) {
-    this.state = state;
-    this.notify = notify;
-  }
-  buildRuntimeMatcher(matcher, source) {
-    if (typeof matcher === "function") {
-      return {
-        source,
-        match: matcher,
-        cacheable: false
-      };
-    }
-    if (isReactiveMatcher(matcher)) {
-      return {
-        source,
-        match: () => matcher.get(),
-        cacheable: true,
-        subscribe: (onChange) => matcher.subscribe(onChange)
-      };
-    }
-    throw new Error(`Keymap ${source} expected a function or a reactive matcher`);
-  }
-  hasNoConditions(target) {
-    return target.requires.length === 0 && target.matchers.length === 0;
-  }
-  indexRuntimeMatchable(target) {
-    if (target.conditionKeys.length > 0) {
-      for (const key of target.conditionKeys) {
-        const dependents = this.state.conditions.runtimeKeyDependents.get(key);
-        if (dependents) {
-          dependents.add(target);
-          continue;
-        }
-        this.state.conditions.runtimeKeyDependents.set(key, new Set([target]));
-      }
-    }
-    if (!target.hasUnkeyedMatchers) {
-      target.matchCacheDirty = true;
-    }
-  }
-  unindexRuntimeMatchable(target) {
-    if (target.conditionKeys.length === 0) {
-      return;
-    }
-    for (const key of target.conditionKeys) {
-      const dependents = this.state.conditions.runtimeKeyDependents.get(key);
-      if (!dependents) {
-        continue;
-      }
-      dependents.delete(target);
-      if (dependents.size === 0) {
-        this.state.conditions.runtimeKeyDependents.delete(key);
-      }
-    }
-  }
-  invalidateRuntimeConditionKey(name) {
-    const dependents = this.state.conditions.runtimeKeyDependents.get(name);
-    if (!dependents) {
-      return;
-    }
-    for (const target of dependents) {
-      target.matchCacheDirty = true;
-    }
-  }
-  matchesConditions(target) {
-    if (this.hasNoConditions(target)) {
-      return true;
-    }
-    if (this.hasFreshConditionCache(target)) {
-      return target.matchCache === true;
-    }
-    const matched = this.matchRequirements(target.requires) && this.matchesRuntimeMatchers(target);
-    this.updateConditionCache(target, matched);
-    return matched;
-  }
-  layerMatchesRuntimeState(layer) {
-    if (this.state.layers.layersWithConditions === 0 || this.hasNoConditions(layer)) {
-      return true;
-    }
-    return this.matchesConditions(layer);
-  }
-  matchRequirements(requires) {
-    if (requires.length === 0) {
-      return true;
-    }
-    for (const [name, value] of requires) {
-      if (!Object.is(this.state.runtime.data[name], value)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  hasFreshConditionCache(target) {
-    if (target.hasUnkeyedMatchers) {
-      return false;
-    }
-    return target.matchCacheDirty !== true && target.matchCache !== undefined;
-  }
-  updateConditionCache(target, matched) {
-    if (target.hasUnkeyedMatchers) {
-      return;
-    }
-    target.matchCacheDirty = false;
-    target.matchCache = matched;
-  }
-  matchesRuntimeMatcher(matcher) {
-    try {
-      return matcher.match();
-    } catch (error) {
-      this.notify.emitError("runtime-matcher-error", error, `[Keymap] Error evaluating runtime matcher from ${matcher.source}:`);
-      return false;
-    }
-  }
-  matchesRuntimeMatchers(target) {
-    if (target.matchers.length === 0) {
-      return true;
-    }
-    if (target.matchers.length === 1) {
-      const [matcher] = target.matchers;
-      return matcher ? this.matchesRuntimeMatcher(matcher) : true;
-    }
-    for (const matcher of target.matchers) {
-      if (!this.matchesRuntimeMatcher(matcher)) {
-        return false;
-      }
-    }
-    return true;
-  }
-}
-
-// src/types.ts
-var KEY_DISAMBIGUATION_DECISION = Symbol("keymap-disambiguation-decision");
-var KEY_DEFERRED_DISAMBIGUATION_DECISION = Symbol("keymap-deferred-disambiguation-decision");
-
-// src/services/dispatch.ts
-function createSyncDecision(action, handler) {
-  return {
-    [KEY_DISAMBIGUATION_DECISION]: true,
-    action,
-    handler
-  };
-}
-function createDeferredDecision(action) {
-  return {
-    [KEY_DEFERRED_DISAMBIGUATION_DECISION]: true,
-    action
-  };
-}
-function isSyncDecision(value) {
-  return !!value && typeof value === "object" && value[KEY_DISAMBIGUATION_DECISION] === true;
-}
-function isDeferredDecision(value) {
-  return !!value && typeof value === "object" && value[KEY_DEFERRED_DISAMBIGUATION_DECISION] === true;
-}
-
-class DispatchService {
-  state;
-  notify;
-  runtime;
-  activation;
-  conditions;
-  executor;
-  compiler;
-  catalog;
-  layers;
-  eventMatchResolverContext;
-  pendingDisambiguation = null;
-  nextPendingDisambiguationId = 0;
-  constructor(state, notify, runtime, activation, conditions, executor, compiler, catalog, layers) {
-    this.state = state;
-    this.notify = notify;
-    this.runtime = runtime;
-    this.activation = activation;
-    this.conditions = conditions;
-    this.executor = executor;
-    this.compiler = compiler;
-    this.catalog = catalog;
-    this.layers = layers;
-    this.eventMatchResolverContext = {
-      resolveKey: (key) => {
-        return this.compiler.parseTokenKey(key).match;
-      }
-    };
-  }
-  intercept(name, fn, options) {
-    if (name === "key") {
-      const keyOptions = options;
-      return this.state.dispatch.keyHooks.register(fn, {
-        priority: keyOptions?.priority ?? 0,
-        release: keyOptions?.release ?? false
-      });
-    }
-    const rawOptions = options;
-    return this.state.dispatch.rawHooks.register(fn, {
-      priority: rawOptions?.priority ?? 0
-    });
-  }
-  prependEventMatchResolver(resolver) {
-    return this.state.dispatch.eventMatchResolvers.prepend(resolver);
-  }
-  appendEventMatchResolver(resolver) {
-    return this.state.dispatch.eventMatchResolvers.append(resolver);
-  }
-  clearEventMatchResolvers() {
-    this.state.dispatch.eventMatchResolvers.clear();
-  }
-  prependDisambiguationResolver(resolver) {
-    return this.mutateDisambiguationResolvers(() => this.state.dispatch.disambiguationResolvers.prepend(resolver), resolver);
-  }
-  appendDisambiguationResolver(resolver) {
-    return this.mutateDisambiguationResolvers(() => this.state.dispatch.disambiguationResolvers.append(resolver), resolver);
-  }
-  clearDisambiguationResolvers() {
-    if (!this.state.dispatch.disambiguationResolvers.has()) {
-      return;
-    }
-    this.notify.runWithStateChangeBatch(() => {
-      this.state.dispatch.disambiguationResolvers.clear();
-      this.layers.recompileBindings();
-    });
-  }
-  handlePendingSequenceChange(_previous, _next) {
-    if (!this.pendingDisambiguation) {
-      return;
-    }
-    this.cancelPendingDisambiguation();
-  }
-  handleRawSequence(sequence) {
-    const hooks = this.state.dispatch.rawHooks.entries();
-    if (hooks.length === 0) {
-      return false;
-    }
-    let stopped = false;
-    const context = {
-      sequence,
-      stop() {
-        stopped = true;
-      }
-    };
-    for (const hook of hooks) {
-      try {
-        hook.listener(context);
-      } catch (error) {
-        this.notify.emitError("raw-intercept-error", error, "[Keymap] Error in raw intercept listener:");
-      }
-      if (stopped) {
-        return true;
-      }
-    }
-    return false;
-  }
-  handleKeyEvent(event, release) {
-    if (!release) {
-      this.cancelPendingDisambiguation();
-    }
-    const hooks = this.state.dispatch.keyHooks.entries();
-    const context = {
-      event,
-      setData: (name, value) => {
-        this.runtime.setData(name, value);
-      },
-      getData: (name) => {
-        return this.runtime.getData(name);
-      },
-      consume: (options) => {
-        const shouldPreventDefault = options?.preventDefault ?? true;
-        const shouldStopPropagation = options?.stopPropagation ?? true;
-        if (shouldPreventDefault) {
-          event.preventDefault();
-        }
-        if (shouldStopPropagation) {
-          event.stopPropagation();
-        }
-      }
-    };
-    for (const hook of hooks) {
-      if (hook.release !== release) {
-        continue;
-      }
-      try {
-        hook.listener(context);
-      } catch (error) {
-        this.notify.emitError("key-intercept-error", error, "[Keymap] Error in key intercept listener:");
-      }
-      if (event.propagationStopped) {
-        return;
-      }
-    }
-    if (release) {
-      this.dispatchReleaseLayers(event);
-      return;
-    }
-    this.dispatchLayers(event);
-  }
-  mutateDisambiguationResolvers(register, resolver) {
-    return this.notify.runWithStateChangeBatch(() => {
-      const hadResolvers = this.state.dispatch.disambiguationResolvers.has();
-      const off = register();
-      if (!hadResolvers && this.state.dispatch.disambiguationResolvers.has()) {
-        this.layers.recompileBindings();
-      }
-      return () => {
-        this.notify.runWithStateChangeBatch(() => {
-          const hadBeforeRemoval = this.state.dispatch.disambiguationResolvers.has();
-          off();
-          if (this.state.dispatch.disambiguationResolvers.values().includes(resolver)) {
-            return;
-          }
-          if (hadBeforeRemoval && !this.state.dispatch.disambiguationResolvers.has()) {
-            this.layers.recompileBindings();
-          }
-        });
-      };
-    });
-  }
-  dispatchReleaseLayers(event) {
-    const focused = this.activation.getFocusedTarget();
-    const activeLayers = this.activation.getActiveLayers(focused);
-    const hasLayerConditions = this.state.layers.layersWithConditions > 0;
-    const matchKeys = this.resolveEventMatchKeys(event);
-    layerLoop:
-      for (const layer of activeLayers) {
-        if (layer.compiledBindings.length === 0) {
-          continue;
-        }
-        if (hasLayerConditions && !this.conditions.hasNoConditions(layer) && !this.conditions.matchesConditions(layer)) {
-          continue;
-        }
-        for (const strokeKey of matchKeys) {
-          const result = this.runReleaseBindings(layer, strokeKey, event, focused);
-          if (!result.handled) {
-            continue;
-          }
-          if (result.stop) {
-            return;
-          }
-          continue layerLoop;
-        }
-      }
-  }
-  dispatchLayers(event) {
-    const focused = this.activation.getFocusedTarget();
-    const pending = this.activation.ensureValidPendingSequence();
-    const matchKeys = this.resolveEventMatchKeys(event);
-    if (pending) {
-      this.dispatchPendingSequence(pending, matchKeys, event, focused);
-      return;
-    }
-    const activeLayers = this.activation.getActiveLayers(focused);
-    this.dispatchFromRoot(activeLayers, matchKeys, event, focused);
-  }
-  dispatchPendingSequence(pending, matchKeys, event, focused) {
-    const advancedCaptures = [];
-    for (const capture of pending.captures) {
-      const nextNode = this.getReachableChild(capture.node, matchKeys, focused);
-      if (!nextNode) {
-        continue;
-      }
-      advancedCaptures.push({
-        layer: capture.layer,
-        node: nextNode
-      });
-    }
-    if (advancedCaptures.length === 0) {
-      this.activation.setPendingSequence(null);
-      return;
-    }
-    this.dispatchPendingCapturesFromIndex(advancedCaptures, 0, false, event, focused);
-  }
-  dispatchPendingCapturesFromIndex(advancedCaptures, startIndex, handledExact, event, focused) {
-    let hasHandledExact = handledExact;
-    for (let index = startIndex;index < advancedCaptures.length; index += 1) {
-      const capture = advancedCaptures[index];
-      if (!capture) {
-        continue;
-      }
-      if (capture.node.children.size > 0) {
-        if (hasHandledExact) {
-          continue;
-        }
-        const continuationCaptures = this.collectPendingCapturesFromAdvanced(advancedCaptures, index);
-        if (this.tryResolvePendingAmbiguity(advancedCaptures, index, continuationCaptures, capture, event, focused, hasHandledExact)) {
-          return;
-        }
-        this.activation.setPendingSequence({ captures: continuationCaptures });
-        event.preventDefault();
-        event.stopPropagation();
-        return;
-      }
-      const result = this.runBindings(capture.layer, capture.node.bindings, event, focused);
-      if (!result.handled) {
-        continue;
-      }
-      hasHandledExact = true;
-      if (result.stop) {
-        this.activation.setPendingSequence(null);
-        return;
-      }
-    }
-    this.activation.setPendingSequence(null);
-  }
-  dispatchFromRoot(activeLayers, matchKeys, event, focused) {
-    this.dispatchFromRootAtIndex(activeLayers, 0, matchKeys, event, focused);
-  }
-  dispatchFromRootAtIndex(activeLayers, startIndex, matchKeys, event, focused) {
-    const hasLayerConditions = this.state.layers.layersWithConditions > 0;
-    for (let index = startIndex;index < activeLayers.length; index += 1) {
-      const layer = activeLayers[index];
-      if (!layer) {
-        continue;
-      }
-      if (layer.root.children.size === 0) {
-        continue;
-      }
-      if (hasLayerConditions && !this.conditions.hasNoConditions(layer) && !this.conditions.matchesConditions(layer)) {
-        continue;
-      }
-      const nextNode = this.getReachableChild(layer.root, matchKeys, focused);
-      if (!nextNode) {
-        continue;
-      }
-      if (nextNode.children.size > 0) {
-        const continuationCaptures = this.collectPendingCapturesFromRoot(activeLayers, index, matchKeys, focused);
-        if (this.tryResolveRootAmbiguity(activeLayers, index, matchKeys, continuationCaptures, layer, nextNode, event, focused)) {
-          return;
-        }
-        this.activation.setPendingSequence({ captures: continuationCaptures });
-        event.preventDefault();
-        event.stopPropagation();
-        return;
-      }
-      const result = this.runBindings(layer, nextNode.bindings, event, focused);
-      if (!result.handled) {
-        continue;
-      }
-      if (result.stop) {
-        return;
-      }
-    }
-  }
-  tryResolveRootAmbiguity(activeLayers, layerIndex, matchKeys, continuationCaptures, layer, node, event, focused) {
-    const applyExact = () => {
-      this.activation.setPendingSequence(null);
-      const result = this.runBindings(layer, node.bindings, event, focused);
-      if (!result.stop) {
-        this.dispatchFromRootAtIndex(activeLayers, layerIndex + 1, matchKeys, event, focused);
-      }
-    };
-    return this.tryResolveAmbiguity({
-      event,
-      focused,
-      continuationCaptures,
-      exactBindingsSource: node.bindings,
-      runExact: applyExact
-    });
-  }
-  tryResolvePendingAmbiguity(advancedCaptures, captureIndex, continuationCaptures, capture, event, focused, handledExact) {
-    const applyExact = () => {
-      this.activation.setPendingSequence(null);
-      const result = this.runBindings(capture.layer, capture.node.bindings, event, focused);
-      if (result.stop) {
-        return;
-      }
-      this.dispatchPendingCapturesFromIndex(advancedCaptures, captureIndex + 1, handledExact || result.handled, event, focused);
-    };
-    return this.tryResolveAmbiguity({
-      event,
-      focused,
-      continuationCaptures,
-      exactBindingsSource: capture.node.bindings,
-      runExact: applyExact
-    });
-  }
-  tryResolveAmbiguity(options) {
-    const { event, focused, continuationCaptures, exactBindingsSource, runExact } = options;
-    if (!this.state.dispatch.disambiguationResolvers.has() || continuationCaptures.length === 0) {
-      return false;
-    }
-    const activeView = this.catalog.getActiveCommandView(focused);
-    const exactBindings = this.activation.collectMatchingBindings(exactBindingsSource, focused, activeView);
-    if (!exactBindings.some((binding) => binding.command !== undefined)) {
-      return false;
-    }
-    const continueSequence = () => {
-      this.activation.setPendingSequence({ captures: continuationCaptures });
-      event.preventDefault();
-      event.stopPropagation();
-    };
-    const clear = () => {
-      this.activation.setPendingSequence(null);
-      event.preventDefault();
-      event.stopPropagation();
-    };
-    let sequence;
-    const getSequence = () => {
-      sequence ??= this.activation.collectSequencePartsFromPending({ captures: continuationCaptures });
-      return sequence;
-    };
-    const decision = this.resolveDisambiguation({
-      event,
-      focused,
-      getSequence,
-      exactBindings,
-      continuationCaptures,
-      activeView
-    });
-    if (!decision) {
-      this.warnUnresolvedAmbiguity(getSequence());
-      continueSequence();
-      return true;
-    }
-    return this.applySyncDecision(decision, continuationCaptures, runExact, continueSequence, clear, focused, getSequence);
-  }
-  applySyncDecision(decision, continuationCaptures, runExact, continueSequence, clear, focused, getSequence) {
-    if (decision.action === "run-exact") {
-      runExact();
-      return true;
-    }
-    if (decision.action === "continue-sequence") {
-      continueSequence();
-      return true;
-    }
-    if (decision.action === "clear") {
-      clear();
-      return true;
-    }
-    continueSequence();
-    this.scheduleDeferredDisambiguation(continuationCaptures, decision.handler, focused, getSequence(), (nextDecision) => {
-      if (!nextDecision) {
-        return;
-      }
-      if (nextDecision.action === "run-exact") {
-        runExact();
-        return;
-      }
-      if (nextDecision.action === "continue-sequence") {
-        continueSequence();
-        return;
-      }
-      clear();
-    });
-    return true;
-  }
-  resolveDisambiguation(options) {
-    const activation = this.activation;
-    const runtime = this.runtime;
-    let sequence;
-    let exact;
-    let continuations;
-    let strokePart;
-    const ctx = {
-      event: options.event,
-      focused: options.focused,
-      get sequence() {
-        sequence ??= cloneKeySequence(options.getSequence());
-        return sequence;
-      },
-      get stroke() {
-        const stroke = options.getSequence().at(-1);
-        if (!stroke) {
-          throw new Error("Disambiguation context expected a non-empty sequence");
-        }
-        strokePart ??= {
-          ...stroke,
-          stroke: cloneKeyStroke(stroke.stroke)
-        };
-        return strokePart;
-      },
-      get exact() {
-        exact ??= activation.collectActiveBindings(options.exactBindings, options.focused, options.activeView).map((binding) => ({
-          ...binding,
-          sequence: cloneKeySequence(binding.sequence)
-        }));
-        return exact;
-      },
-      get continuations() {
-        continuations ??= activation.getActiveKeysForCaptures(options.continuationCaptures, {
-          includeBindings: true,
-          includeMetadata: true
-        });
-        return continuations;
-      },
-      getData: (name) => {
-        return runtime.getData(name);
-      },
-      setData: (name, value) => {
-        runtime.setData(name, value);
-      },
-      runExact: () => createSyncDecision("run-exact"),
-      continueSequence: () => createSyncDecision("continue-sequence"),
-      clear: () => createSyncDecision("clear"),
-      defer: (run) => createSyncDecision("defer", run)
-    };
-    for (const resolver of this.state.dispatch.disambiguationResolvers.values()) {
-      let result;
-      try {
-        result = resolver(ctx);
-      } catch (error) {
-        this.notify.emitError("disambiguation-resolver-error", error, "[Keymap] Error in disambiguation resolver:");
-        continue;
-      }
-      if (result === undefined) {
-        continue;
-      }
-      if (isPromiseLike(result)) {
-        this.notify.emitError("invalid-disambiguation-resolver-return", result, "[Keymap] Disambiguation resolvers must return synchronously; use ctx.defer(...) for async handling");
-        continue;
-      }
-      if (!isSyncDecision(result)) {
-        this.notify.emitError("invalid-disambiguation-decision", result, "[Keymap] Invalid disambiguation decision returned by resolver:");
-        continue;
-      }
-      return result;
-    }
-    return;
-  }
-  scheduleDeferredDisambiguation(captures, handler, focused, sequence, apply) {
-    this.cancelPendingDisambiguation();
-    const controller = new AbortController;
-    const pending = {
-      id: this.nextPendingDisambiguationId++,
-      controller,
-      captures,
-      apply
-    };
-    this.pendingDisambiguation = pending;
-    queueMicrotask(() => {
-      this.executeDeferredDisambiguation(pending, handler, focused, sequence);
-    });
-  }
-  executeDeferredDisambiguation(pending, handler, focused, sequence) {
-    if (!this.isPendingDisambiguationCurrent(pending)) {
-      return;
-    }
-    const ctx = {
-      signal: pending.controller.signal,
-      sequence: cloneKeySequence(sequence),
-      focused,
-      sleep: (ms) => {
-        return this.sleepWithSignal(ms, pending.controller.signal);
-      },
-      runExact: () => createDeferredDecision("run-exact"),
-      continueSequence: () => createDeferredDecision("continue-sequence"),
-      clear: () => createDeferredDecision("clear")
-    };
-    let result;
-    try {
-      result = handler(ctx);
-    } catch (error) {
-      if (this.isPendingDisambiguationCurrent(pending)) {
-        this.notify.emitError("deferred-disambiguation-error", error, "[Keymap] Error in deferred disambiguation handler:");
-        this.finishPendingDisambiguation(pending);
-      }
-      return;
-    }
-    if (isPromiseLike(result)) {
-      result.then((resolved) => {
-        this.applyDeferredDisambiguationResult(pending, resolved);
-      }).catch((error) => {
-        if (!this.isPendingDisambiguationCurrent(pending)) {
-          return;
-        }
-        this.notify.emitError("deferred-disambiguation-error", error, "[Keymap] Error in deferred disambiguation handler:");
-        this.finishPendingDisambiguation(pending);
-      });
-      return;
-    }
-    this.applyDeferredDisambiguationResult(pending, result);
-  }
-  applyDeferredDisambiguationResult(pending, result) {
-    if (!this.isPendingDisambiguationCurrent(pending)) {
-      return;
-    }
-    if (result !== undefined && !isDeferredDecision(result)) {
-      this.notify.emitError("invalid-deferred-disambiguation-decision", result, "[Keymap] Invalid deferred disambiguation decision returned by handler:");
-      this.finishPendingDisambiguation(pending);
-      return;
-    }
-    this.finishPendingDisambiguation(pending);
-    pending.apply(result);
-  }
-  finishPendingDisambiguation(pending) {
-    if (!this.isPendingDisambiguationCurrent(pending)) {
-      return;
-    }
-    this.pendingDisambiguation = null;
-  }
-  cancelPendingDisambiguation() {
-    const pending = this.pendingDisambiguation;
-    if (!pending) {
-      return;
-    }
-    this.pendingDisambiguation = null;
-    pending.controller.abort();
-  }
-  isPendingDisambiguationCurrent(pending) {
-    return this.pendingDisambiguation === pending;
-  }
-  sleepWithSignal(ms, signal) {
-    if (signal.aborted) {
-      return Promise.resolve(false);
-    }
-    return new Promise((resolve) => {
-      const timeout = setTimeout(() => {
-        signal.removeEventListener("abort", onAbort);
-        resolve(true);
-      }, Math.max(0, ms));
-      const onAbort = () => {
-        clearTimeout(timeout);
-        signal.removeEventListener("abort", onAbort);
-        resolve(false);
-      };
-      signal.addEventListener("abort", onAbort, { once: true });
-    });
-  }
-  warnUnresolvedAmbiguity(sequence) {
-    const display = stringifyKeySequence(sequence, { preferDisplay: true });
-    this.notify.warnOnce(`unresolved-disambiguation:${display}`, "unresolved-disambiguation", { sequence: display }, `[Keymap] Ambiguous exact/prefix sequence "${display}" fell back to prefix handling because no disambiguation resolver resolved it`);
-  }
-  collectPendingCapturesFromRoot(activeLayers, startIndex, matchKeys, focused) {
-    const captures = [];
-    const hasLayerConditions = this.state.layers.layersWithConditions > 0;
-    for (let index = startIndex;index < activeLayers.length; index += 1) {
-      const layer = activeLayers[index];
-      if (!layer || layer.root.children.size === 0) {
-        continue;
-      }
-      if (hasLayerConditions && !this.conditions.hasNoConditions(layer) && !this.conditions.matchesConditions(layer)) {
-        continue;
-      }
-      const nextNode = this.getReachableChild(layer.root, matchKeys, focused);
-      if (!nextNode || nextNode.children.size === 0) {
-        continue;
-      }
-      captures.push({
-        layer,
-        node: nextNode
-      });
-    }
-    return captures;
-  }
-  collectPendingCapturesFromAdvanced(advancedCaptures, startIndex) {
-    return advancedCaptures.filter((candidate, candidateIndex) => {
-      return candidateIndex >= startIndex && candidate.node.children.size > 0;
-    });
-  }
-  resolveEventMatchKeys(event) {
-    const resolvers = this.state.dispatch.eventMatchResolvers.values();
-    if (resolvers.length === 0) {
-      return [];
-    }
-    if (resolvers.length === 1) {
-      return resolveSingleEventMatchKeys(resolvers[0], event, this.eventMatchResolverContext, this.notify);
-    }
-    const keys = [];
-    const seen = new Set;
-    for (const resolver of resolvers) {
-      let resolved;
-      try {
-        resolved = resolver(event, this.eventMatchResolverContext);
-      } catch (error) {
-        this.notify.emitError("event-match-resolver-error", error, "[Keymap] Error in event match resolver:");
-        continue;
-      }
-      if (!resolved || resolved.length === 0) {
-        continue;
-      }
-      for (const candidate of resolved) {
-        if (typeof candidate !== "string") {
-          this.notify.emitError("invalid-event-match-resolver-candidate", candidate, "[Keymap] Invalid event match resolver candidate:");
-          continue;
-        }
-        if (seen.has(candidate)) {
-          continue;
-        }
-        seen.add(candidate);
-        keys.push(candidate);
-      }
-    }
-    return keys;
-  }
-  runReleaseBindings(layer, strokeKey, event, focused) {
-    let handled = false;
-    for (const binding of layer.compiledBindings) {
-      if (binding.event !== "release") {
-        continue;
-      }
-      const firstPart = binding.sequence[0];
-      if (!firstPart || firstPart.match !== strokeKey) {
-        continue;
-      }
-      if (!this.conditions.matchesConditions(binding)) {
-        continue;
-      }
-      const bindingHandled = this.executor.runBinding(layer, binding, event, focused);
-      if (!bindingHandled) {
-        continue;
-      }
-      handled = true;
-      if (!binding.fallthrough) {
-        return { handled: true, stop: true };
-      }
-    }
-    return { handled, stop: false };
-  }
-  getReachableChild(node, matchKeys, focused) {
-    for (const strokeKey of matchKeys) {
-      const child = node.children.get(strokeKey);
-      if (!child || !this.activation.nodeHasReachableBindings(child, focused)) {
-        continue;
-      }
-      return child;
-    }
-    return;
-  }
-  runBindings(layer, bindings, event, focused) {
-    let handled = false;
-    for (const binding of bindings) {
-      if (!this.conditions.matchesConditions(binding)) {
-        continue;
-      }
-      const bindingHandled = this.executor.runBinding(layer, binding, event, focused);
-      if (!bindingHandled) {
-        continue;
-      }
-      handled = true;
-      if (!binding.fallthrough) {
-        return { handled: true, stop: true };
-      }
-    }
-    return { handled, stop: false };
-  }
-}
-function resolveSingleEventMatchKeys(resolver, event, ctx, notify) {
-  let resolved;
-  try {
-    resolved = resolver(event, ctx);
-  } catch (error) {
-    notify.emitError("event-match-resolver-error", error, "[Keymap] Error in event match resolver:");
-    return [];
-  }
-  if (!resolved || resolved.length === 0) {
-    return [];
-  }
-  if (resolved.length === 1) {
-    const [candidate] = resolved;
-    if (typeof candidate !== "string") {
-      notify.emitError("invalid-event-match-resolver-candidate", candidate, "[Keymap] Invalid event match resolver candidate:");
-      return [];
-    }
-    return [candidate];
-  }
-  const keys = [];
-  const seen = new Set;
-  for (const candidate of resolved) {
-    if (typeof candidate !== "string") {
-      notify.emitError("invalid-event-match-resolver-candidate", candidate, "[Keymap] Invalid event match resolver candidate:");
-      continue;
-    }
-    if (seen.has(candidate)) {
-      continue;
-    }
-    seen.add(candidate);
-    keys.push(candidate);
-  }
-  return keys;
-}
-
-// src/services/environment.ts
-var NOOP = () => {};
-function registerFieldCompilers(fields, options) {
-  const { kind, reservedFields, registeredFields, emitError } = options;
-  const entries = Object.entries(fields);
-  const registered = [];
-  for (const [name] of entries) {
-    if (reservedFields.has(name)) {
-      emitError(`reserved-${kind}-field`, { field: name, kind }, `Keymap ${kind} field "${name}" is reserved`);
-      continue;
-    }
-    if (registeredFields.has(name)) {
-      emitError(`duplicate-${kind}-field`, { field: name, kind }, `Keymap ${kind} field "${name}" is already registered`);
-    }
-  }
-  for (const [name, compiler] of entries) {
-    if (reservedFields.has(name) || registeredFields.has(name)) {
-      continue;
-    }
-    registeredFields.set(name, compiler);
-    registered.push([name, compiler]);
-  }
-  return () => {
-    for (const [name, compiler] of registered) {
-      const current = registeredFields.get(name);
-      if (current === compiler) {
-        registeredFields.delete(name);
-      }
-    }
-  };
-}
-
-class EnvironmentService {
-  state;
-  notify;
-  compiler;
-  layers;
-  constructor(state, notify, compiler, layers) {
-    this.state = state;
-    this.notify = notify;
-    this.compiler = compiler;
-    this.layers = layers;
-  }
-  prependBindingTransformer(transformer) {
-    return this.state.environment.bindingTransformers.prepend(transformer);
-  }
-  appendBindingTransformer(transformer) {
-    return this.state.environment.bindingTransformers.append(transformer);
-  }
-  clearBindingTransformers() {
-    this.state.environment.bindingTransformers.clear();
-  }
-  prependBindingParser(parser) {
-    return this.state.environment.bindingParsers.prepend(parser);
-  }
-  appendBindingParser(parser) {
-    return this.state.environment.bindingParsers.append(parser);
-  }
-  clearBindingParsers() {
-    this.state.environment.bindingParsers.clear();
-  }
-  registerToken(token) {
-    let normalizedToken;
-    try {
-      normalizedToken = normalizeBindingTokenName(token.name);
-    } catch (error) {
-      this.notify.emitError("token-name-normalize-error", error, getErrorMessage(error, "Failed to register keymap token"));
-      return NOOP;
-    }
-    if (this.state.environment.tokens.has(normalizedToken)) {
-      this.notify.emitError("duplicate-token", { token: normalizedToken }, `Keymap token "${normalizedToken}" is already registered`);
-      return NOOP;
-    }
-    let parsedToken;
-    try {
-      parsedToken = this.compiler.parseTokenKey(token.key);
-    } catch (error) {
-      this.notify.emitError("token-parse-error", error, getErrorMessage(error, `Failed to register keymap token "${normalizedToken}"`));
-      return NOOP;
-    }
-    const registeredToken = {
-      stroke: parsedToken.stroke,
-      match: parsedToken.match
-    };
-    const nextTokens = new Map(this.state.environment.tokens);
-    nextTokens.set(normalizedToken, registeredToken);
-    try {
-      this.layers.applyTokenState(nextTokens);
-    } catch (error) {
-      this.notify.emitError("token-register-error", error, getErrorMessage(error, `Failed to register keymap token "${normalizedToken}"`));
-      return NOOP;
-    }
-    return () => {
-      const current = this.state.environment.tokens.get(normalizedToken);
-      if (current !== registeredToken) {
-        return;
-      }
-      const nextTokens2 = new Map(this.state.environment.tokens);
-      nextTokens2.delete(normalizedToken);
-      try {
-        this.layers.applyTokenState(nextTokens2);
-      } catch (error) {
-        this.notify.emitError("token-unregister-error", error, getErrorMessage(error, `Failed to unregister keymap token "${normalizedToken}"`));
-      }
-    };
-  }
-  prependBindingExpander(expander) {
-    return this.state.environment.bindingExpanders.prepend(expander);
-  }
-  appendBindingExpander(expander) {
-    return this.state.environment.bindingExpanders.append(expander);
-  }
-  clearBindingExpanders() {
-    this.state.environment.bindingExpanders.clear();
-  }
-  registerLayerFields(fields) {
-    return registerFieldCompilers(fields, {
-      kind: "layer",
-      reservedFields: RESERVED_LAYER_FIELDS,
-      registeredFields: this.state.environment.layerFields,
-      emitError: (code, error, message) => {
-        this.notify.emitError(code, error, message);
-      }
-    });
-  }
-  registerBindingFields(fields) {
-    return registerFieldCompilers(fields, {
-      kind: "binding",
-      reservedFields: RESERVED_BINDING_FIELDS,
-      registeredFields: this.state.environment.bindingFields,
-      emitError: (code, error, message) => {
-        this.notify.emitError(code, error, message);
-      }
-    });
-  }
-  registerCommandFields(fields) {
-    return registerFieldCompilers(fields, {
-      kind: "command",
-      reservedFields: RESERVED_COMMAND_FIELDS,
-      registeredFields: this.state.environment.commandFields,
-      emitError: (code, error, message) => {
-        this.notify.emitError(code, error, message);
-      }
-    });
-  }
-}
-
-// src/services/layers.ts
-var NOOP2 = () => {};
-function sortLayers(layers) {
-  return [...layers].sort((left, right) => {
-    const priorityDiff = right.priority - left.priority;
-    if (priorityDiff !== 0) {
-      return priorityDiff;
-    }
-    return right.order - left.order;
-  });
-}
-function createCommandLookup(commands) {
-  if (commands.length === 0) {
-    return;
-  }
-  const lookup = new Map;
-  for (const command of commands) {
-    lookup.set(command.name, command);
-  }
-  return lookup;
-}
-function addRegisteredCommandNames(target, commands) {
-  for (const command of commands) {
-    target.set(command.name, (target.get(command.name) ?? 0) + 1);
-  }
-}
-function removeRegisteredCommandNames(target, commands) {
-  for (const command of commands) {
-    const count = target.get(command.name);
-    if (!count || count <= 1) {
-      target.delete(command.name);
-      continue;
-    }
-    target.set(command.name, count - 1);
-  }
-}
-function getSequenceNode(root, sequence) {
-  let node = root;
-  for (const part of sequence) {
-    node = node.children.get(part.match);
-    if (!node) {
-      return;
-    }
-  }
-  return node;
-}
-function buildLayerBindingAnalyses(root, compiledBindings) {
-  return compiledBindings.map((binding) => {
-    const node = binding.event === "press" ? getSequenceNode(root, binding.sequence) : undefined;
-    return {
-      sequence: cloneKeySequence(binding.sequence),
-      command: binding.command,
-      attrs: binding.attrs,
-      event: binding.event,
-      preventDefault: binding.preventDefault,
-      fallthrough: binding.fallthrough,
-      sourceBinding: snapshotParsedBindingInput(binding.sourceBinding),
-      sourceTarget: binding.sourceTarget,
-      sourceLayerOrder: binding.sourceLayerOrder,
-      sourceBindingIndex: binding.sourceBindingIndex,
-      hasCommandAtSequence: node ? node.bindings.some((candidate) => candidate.command !== undefined) : false,
-      hasContinuations: node ? node.children.size > 0 : false
-    };
-  });
-}
-
-class LayerService {
-  state;
-  notify;
-  conditions;
-  activation;
-  options;
-  constructor(state, notify, conditions, activation, options) {
-    this.state = state;
-    this.notify = notify;
-    this.conditions = conditions;
-    this.activation = activation;
-    this.options = options;
-  }
-  registerLayer(layer) {
-    return this.notify.runWithStateChangeBatch(() => {
-      const target = layer.target;
-      if (target && this.options.host.isTargetDestroyed(target)) {
-        this.notify.emitError("destroyed-layer-target", { target }, "Cannot register a keymap layer for a destroyed keymap target");
-        return NOOP2;
-      }
-      let bindingInputs;
-      let requires;
-      let matchers;
-      let conditionKeys;
-      let hasUnkeyedMatchers;
-      let compileFields;
-      let commands;
-      let commandLookup;
-      let targetMode;
-      try {
-        targetMode = this.normalizeTargetMode(layer);
-        bindingInputs = snapshotBindingInputs(layer.bindings ?? []);
-        commands = !layer.commands || layer.commands.length === 0 ? [] : this.options.commands.normalizeCommands(layer.commands);
-        commandLookup = createCommandLookup(commands);
-        ({ requires, matchers, conditionKeys, hasUnkeyedMatchers, compileFields } = this.compileLayerRuntimeState(layer));
-      } catch (error) {
-        this.notify.emitError("register-layer-failed", error, getErrorMessage(error, "Failed to register keymap layer"));
-        return NOOP2;
-      }
-      const order = this.state.core.order++;
-      const compiledBindings = this.options.compiler.compileBindings(bindingInputs, this.state.environment.tokens, target, order, compileFields);
-      if (compiledBindings.bindings.length === 0 && !compiledBindings.hasTokenBindings && commands.length === 0) {
-        return NOOP2;
-      }
-      this.runLayerAnalyzers({
-        target,
-        order,
-        commandLookup,
-        bindingInputs,
-        compiledBindings: compiledBindings.bindings,
-        root: compiledBindings.root,
-        hasTokenBindings: compiledBindings.hasTokenBindings
-      });
-      const registeredLayer = {
-        order,
-        target,
-        targetMode,
-        priority: layer.priority ?? 0,
-        requires,
-        matchers,
-        conditionKeys,
-        hasUnkeyedMatchers,
-        matchCacheDirty: true,
-        compileFields,
-        commands,
-        commandLookup,
-        bindingInputs,
-        compiledBindings: compiledBindings.bindings,
-        hasUnkeyedCommands: commands.some((command) => command.hasUnkeyedMatchers),
-        hasUnkeyedBindings: compiledBindings.bindings.some((binding) => binding.hasUnkeyedMatchers),
-        hasTokenBindings: compiledBindings.hasTokenBindings,
-        root: compiledBindings.root
-      };
-      this.state.layers.layers.add(registeredLayer);
-      if (registeredLayer.commands.length > 0) {
-        this.state.layers.layersWithCommands += 1;
-        this.state.commands.commandMetadataVersion += 1;
-        addRegisteredCommandNames(this.state.commands.registeredNames, registeredLayer.commands);
-      }
-      if (registeredLayer.requires.length > 0 || registeredLayer.matchers.length > 0) {
-        this.state.layers.layersWithConditions += 1;
-      }
-      this.connectRuntimeMatchable(registeredLayer);
-      for (const command of registeredLayer.commands) {
-        this.connectRuntimeMatchable(command);
-      }
-      for (const binding of registeredLayer.compiledBindings) {
-        this.connectRuntimeMatchable(binding);
-      }
-      this.indexLayer(registeredLayer);
-      this.activation.invalidateActiveLayers();
-      this.activation.refreshActiveLayers();
-      if (target) {
-        const onTargetDestroy = () => {
-          this.unregisterLayer(registeredLayer);
-        };
-        registeredLayer.offTargetDestroy = this.options.host.onTargetDestroy(target, onTargetDestroy);
-      }
-      if (registeredLayer.commands.length > 0) {
-        this.activation.ensureValidPendingSequence();
-      }
-      this.notify.queueStateChange();
-      return () => {
-        this.unregisterLayer(registeredLayer);
-      };
-    });
-  }
-  applyTokenState(nextTokens) {
-    this.notify.runWithStateChangeBatch(() => {
-      const nextCompilations = new Map;
-      for (const layer of this.state.layers.layers) {
-        if (!layer.hasTokenBindings) {
-          continue;
-        }
-        nextCompilations.set(layer, this.compileLayerBindings(layer, nextTokens));
-      }
-      this.state.environment.tokens = nextTokens;
-      let shouldClearPending = false;
-      for (const [layer, compilation] of nextCompilations) {
-        if (this.applyCompiledBindings(layer, compilation)) {
-          shouldClearPending = true;
-        }
-      }
-      if (shouldClearPending) {
-        this.activation.setPendingSequence(null);
-      }
-      if (nextCompilations.size > 0) {
-        this.notify.queueStateChange();
-      }
-    });
-  }
-  recompileBindings() {
-    this.notify.runWithStateChangeBatch(() => {
-      let recompiledLayers = 0;
-      let shouldClearPending = false;
-      for (const layer of this.state.layers.layers) {
-        if (layer.bindingInputs.length === 0) {
-          continue;
-        }
-        const compilation = this.compileLayerBindings(layer, this.state.environment.tokens);
-        if (this.applyCompiledBindings(layer, compilation)) {
-          shouldClearPending = true;
-        }
-        recompiledLayers += 1;
-      }
-      if (shouldClearPending) {
-        this.activation.setPendingSequence(null);
-      }
-      if (recompiledLayers > 0) {
-        this.notify.queueStateChange();
-      }
-    });
-  }
-  prependLayerAnalyzer(analyzer) {
-    return this.state.layers.layerAnalyzers.prepend(analyzer);
-  }
-  appendLayerAnalyzer(analyzer) {
-    return this.state.layers.layerAnalyzers.append(analyzer);
-  }
-  clearLayerAnalyzers() {
-    this.state.layers.layerAnalyzers.clear();
-  }
-  cleanup() {
-    for (const layer of this.state.layers.layers) {
-      this.disconnectRuntimeMatchable(layer);
-      for (const command of layer.commands) {
-        this.disconnectRuntimeMatchable(command);
-      }
-      for (const binding of layer.compiledBindings) {
-        this.disconnectRuntimeMatchable(binding);
-      }
-      layer.offTargetDestroy?.();
-      layer.offTargetDestroy = undefined;
-    }
-  }
-  normalizeTargetMode(layer) {
-    if (layer.targetMode) {
-      if (!layer.target) {
-        throw new Error(`Keymap targetMode "${layer.targetMode}" requires a target`);
-      }
-      return layer.targetMode;
-    }
-    return layer.target ? "focus-within" : undefined;
-  }
-  runLayerAnalyzers(options) {
-    const analyzers = this.state.layers.layerAnalyzers.values();
-    if (analyzers.length === 0) {
-      return;
-    }
-    const bindings = buildLayerBindingAnalyses(options.root, options.compiledBindings);
-    const ctx = {
-      target: options.target,
-      order: options.order,
-      bindingInputs: options.bindingInputs,
-      bindings,
-      hasTokenBindings: options.hasTokenBindings,
-      checkCommandResolution: (command) => {
-        return this.options.commands.getCommandResolutionStatus(command, options.commandLookup);
-      },
-      warn: (code, warning, message) => {
-        this.notify.emitWarning(code, warning, message);
-      },
-      warnOnce: (key, code, warning, message) => {
-        this.notify.warnOnce(key, code, warning, message);
-      },
-      error: (code, error, message) => {
-        this.notify.emitError(code, error, message);
-      }
-    };
-    for (const analyzer of analyzers) {
-      try {
-        analyzer(ctx);
-      } catch (error) {
-        this.notify.emitError("layer-analyzer-error", error, "[Keymap] Error in layer analyzer:");
-      }
-    }
-  }
-  compileLayerRuntimeState(layer) {
-    const mergedRequires = {};
-    const matchers = [];
-    const compileFields = Object.create(null);
-    const conditionKeys = new Set;
-    let hasUnkeyedMatchers = false;
-    for (const [fieldName, value] of Object.entries(layer)) {
-      if (RESERVED_LAYER_FIELDS.has(fieldName)) {
-        continue;
-      }
-      if (value === undefined) {
-        continue;
-      }
-      compileFields[fieldName] = snapshotDataValue(value);
-      const compiler = this.state.environment.layerFields.get(fieldName);
-      if (!compiler) {
-        this.options.warnUnknownField("layer", fieldName);
-        continue;
-      }
-      compiler(value, {
-        require: (name, requiredValue) => {
-          mergeRequirement(mergedRequires, name, requiredValue, `field ${fieldName}`);
-          conditionKeys.add(name);
-        },
-        activeWhen: (matcher) => {
-          const runtimeMatcher = this.conditions.buildRuntimeMatcher(matcher, `field ${fieldName}`);
-          if (!runtimeMatcher.cacheable) {
-            hasUnkeyedMatchers = true;
-          }
-          matchers.push(runtimeMatcher);
-        }
-      });
-    }
-    return {
-      requires: Object.entries(mergedRequires),
-      matchers,
-      conditionKeys: [...conditionKeys],
-      hasUnkeyedMatchers,
-      compileFields: Object.keys(compileFields).length > 0 ? Object.freeze(compileFields) : undefined
-    };
-  }
-  compileLayerBindings(layer, tokens) {
-    return this.options.compiler.compileBindings(layer.bindingInputs, tokens, layer.target, layer.order, layer.compileFields);
-  }
-  applyCompiledBindings(layer, compilation) {
-    this.runLayerAnalyzers({
-      target: layer.target,
-      order: layer.order,
-      commandLookup: layer.commandLookup,
-      bindingInputs: layer.bindingInputs,
-      compiledBindings: compilation.bindings,
-      root: compilation.root,
-      hasTokenBindings: compilation.hasTokenBindings
-    });
-    for (const binding of layer.compiledBindings) {
-      this.disconnectRuntimeMatchable(binding);
-    }
-    layer.root = compilation.root;
-    layer.compiledBindings = compilation.bindings;
-    layer.hasUnkeyedBindings = compilation.bindings.some((binding) => binding.hasUnkeyedMatchers);
-    layer.hasTokenBindings = compilation.hasTokenBindings;
-    for (const binding of layer.compiledBindings) {
-      this.connectRuntimeMatchable(binding);
-    }
-    return this.state.projection.pendingSequence?.captures.some((capture) => capture.layer === layer) ?? false;
-  }
-  indexLayer(layer) {
-    this.state.layers.sortedLayers = sortLayers([...this.state.layers.sortedLayers, layer]);
-    this.state.layers.activeLayersVersion += 1;
-  }
-  removeLayerFromIndex(layer) {
-    this.state.layers.sortedLayers = this.state.layers.sortedLayers.filter((candidate) => candidate !== layer);
-    this.state.layers.activeLayersVersion += 1;
-  }
-  unregisterLayer(layer) {
-    this.notify.runWithStateChangeBatch(() => {
-      if (!this.state.layers.layers.delete(layer)) {
-        return;
-      }
-      if (layer.requires.length > 0 || layer.matchers.length > 0) {
-        this.state.layers.layersWithConditions -= 1;
-      }
-      if (layer.commands.length > 0) {
-        this.state.layers.layersWithCommands -= 1;
-        this.state.commands.commandMetadataVersion += 1;
-        removeRegisteredCommandNames(this.state.commands.registeredNames, layer.commands);
-      }
-      this.disconnectRuntimeMatchable(layer);
-      for (const command of layer.commands) {
-        this.disconnectRuntimeMatchable(command);
-      }
-      for (const binding of layer.compiledBindings) {
-        this.disconnectRuntimeMatchable(binding);
-      }
-      this.removeLayerFromIndex(layer);
-      this.activation.invalidateActiveLayers();
-      this.activation.refreshActiveLayers();
-      layer.offTargetDestroy?.();
-      layer.offTargetDestroy = undefined;
-      if (this.state.projection.pendingSequence?.captures.some((capture) => capture.layer === layer)) {
-        this.activation.setPendingSequence(null);
-      } else if (layer.commands.length > 0 && !this.options.host.isDestroyed) {
-        this.activation.ensureValidPendingSequence();
-      }
-      this.notify.queueStateChange();
-    });
-  }
-  connectRuntimeMatchable(target) {
-    this.attachReactiveMatchers(target);
-    this.conditions.indexRuntimeMatchable(target);
-  }
-  disconnectRuntimeMatchable(target) {
-    this.detachReactiveMatchers(target);
-    this.conditions.unindexRuntimeMatchable(target);
-  }
-  attachReactiveMatchers(target) {
-    for (const matcher of target.matchers) {
-      if (!matcher.subscribe) {
-        continue;
-      }
-      try {
-        matcher.dispose = matcher.subscribe(() => {
-          target.matchCacheDirty = true;
-          if (!this.activation.hasPendingSequenceState()) {
-            this.notify.queueStateChange();
-            return;
-          }
-          this.notify.runWithStateChangeBatch(() => {
-            this.activation.revalidatePendingSequenceIfNeeded();
-            this.notify.queueStateChange();
-          });
-        });
-      } catch (error) {
-        this.notify.emitError("reactive-matcher-subscribe-error", error, getErrorMessage(error, `Failed to subscribe to reactive matcher from ${matcher.source}`));
-      }
-    }
-  }
-  detachReactiveMatchers(target) {
-    for (const matcher of target.matchers) {
-      if (!matcher.dispose) {
-        continue;
-      }
-      try {
-        matcher.dispose();
-      } catch (error) {
-        this.notify.emitError("reactive-matcher-dispose-error", error, getErrorMessage(error, `Failed to dispose reactive matcher from ${matcher.source}`));
-      }
-      matcher.dispose = undefined;
-    }
-  }
-}
-
-// src/lib/emitter.ts
-class Emitter {
-  onError;
-  listeners = Object.create(null);
-  constructor(onError) {
-    this.onError = onError;
-  }
-  hook(name, listener) {
-    const current = this.listeners[name] ?? [];
-    this.listeners[name] = [...current, listener];
-    return () => {
-      const current2 = this.listeners[name];
-      if (!current2 || current2.length === 0) {
-        return;
-      }
-      const next = current2.filter((candidate) => candidate !== listener);
-      if (next.length === 0) {
-        delete this.listeners[name];
-        return;
-      }
-      this.listeners[name] = next;
-    };
-  }
-  has(name) {
-    return (this.listeners[name]?.length ?? 0) > 0;
-  }
-  off(name, listener) {
-    const current = this.listeners[name];
-    if (!current || current.length === 0) {
-      return;
-    }
-    const next = current.filter((candidate) => candidate !== listener);
-    if (next.length === current.length) {
-      return;
-    }
-    if (next.length === 0) {
-      delete this.listeners[name];
-      return;
-    }
-    this.listeners[name] = next;
-  }
-  clear() {
-    this.listeners = Object.create(null);
-  }
-  emit(name, ...args) {
-    const listeners = this.listeners[name];
-    if (!listeners || listeners.length === 0) {
-      return;
-    }
-    for (const listener of listeners) {
-      try {
-        if (args.length === 0) {
-          listener();
-        } else {
-          listener(args[0]);
-        }
-      } catch (error) {
-        this.onError(name, error);
-      }
-    }
-  }
-}
-
-// src/services/notify.ts
-var MAX_STATE_CHANGE_FLUSH_ITERATIONS = 1000;
-
-class NotificationService {
-  state;
-  events;
-  hooks;
-  constructor(state, events, hooks) {
-    this.state = state;
-    this.events = events;
-    this.hooks = hooks;
-  }
-  runWithStateChangeBatch(fn) {
-    this.state.notify.stateChangeDepth += 1;
-    try {
-      return fn();
-    } finally {
-      this.state.notify.stateChangeDepth -= 1;
-      if (this.state.notify.stateChangeDepth === 0) {
-        this.flushStateChange();
-      }
-    }
-  }
-  queueStateChange() {
-    this.state.notify.derivedStateVersion += 1;
-    if (!this.hooks.has("state")) {
-      return;
-    }
-    this.state.notify.stateChangePending = true;
-    if (this.state.notify.stateChangeDepth === 0 && !this.state.notify.flushingStateChange) {
-      this.flushStateChange();
-    }
-  }
-  emitWarning(code, warning, message) {
-    if (!this.events.has("warning")) {
-      const consoleMessage = `[${code}] ${message}`;
-      if (warning instanceof Error) {
-        console.warn(consoleMessage, warning);
-      } else {
-        console.warn(consoleMessage);
-      }
-      return;
-    }
-    this.events.emit("warning", { code, message, warning });
-  }
-  emitError(code, error, message) {
-    if (!this.events.has("error")) {
-      const consoleMessage = `[${code}] ${message}`;
-      if (error instanceof Error) {
-        console.error(consoleMessage, error);
-      } else {
-        console.error(consoleMessage);
-      }
-      return;
-    }
-    this.events.emit("error", { code, message, error });
-  }
-  reportListenerError(name, error) {
-    if (name === "state") {
-      this.emitError("state-listener-error", error, "[Keymap] Error in state listener:");
-      return;
-    }
-    if (name === "pendingSequence") {
-      this.emitError("pending-sequence-listener-error", error, "[Keymap] Error in pending sequence listener:");
-      return;
-    }
-  }
-  warnOnce(key, code, warning, message) {
-    if (this.state.notify.usedWarningKeys.has(key)) {
-      return;
-    }
-    this.state.notify.usedWarningKeys.add(key);
-    this.emitWarning(code, warning, message);
-  }
-  flushStateChange() {
-    if (!this.state.notify.stateChangePending || this.state.notify.stateChangeDepth > 0 || this.state.notify.flushingStateChange) {
-      return;
-    }
-    this.state.notify.flushingStateChange = true;
-    try {
-      let iterations = 0;
-      while (this.state.notify.stateChangePending && this.state.notify.stateChangeDepth === 0) {
-        if (iterations >= MAX_STATE_CHANGE_FLUSH_ITERATIONS) {
-          this.state.notify.stateChangePending = false;
-          this.emitError("state-change-feedback-loop", { iterations: MAX_STATE_CHANGE_FLUSH_ITERATIONS }, `[Keymap] Possible infinite state listener feedback loop detected after ${MAX_STATE_CHANGE_FLUSH_ITERATIONS} iterations; pending state notifications were dropped`);
-          break;
-        }
-        iterations += 1;
-        this.state.notify.stateChangePending = false;
-        this.hooks.emit("state");
-      }
-    } finally {
-      this.state.notify.flushingStateChange = false;
-    }
-  }
-}
-
-// src/services/runtime.ts
-class RuntimeService {
-  state;
-  notify;
-  conditions;
-  activation;
-  constructor(state, notify, conditions, activation) {
-    this.state = state;
-    this.notify = notify;
-    this.conditions = conditions;
-    this.activation = activation;
-  }
-  getData(name) {
-    return this.state.runtime.data[name];
-  }
-  setData(name, value) {
-    this.notify.runWithStateChangeBatch(() => {
-      if (value === undefined) {
-        if (!(name in this.state.runtime.data)) {
-          return;
-        }
-        delete this.state.runtime.data[name];
-        this.state.runtime.dataVersion += 1;
-        this.conditions.invalidateRuntimeConditionKey(name);
-        this.activation.ensureValidPendingSequence();
-        this.notify.queueStateChange();
-        return;
-      }
-      if (Object.is(this.state.runtime.data[name], value)) {
-        return;
-      }
-      this.state.runtime.data[name] = value;
-      this.state.runtime.dataVersion += 1;
-      this.conditions.invalidateRuntimeConditionKey(name);
-      this.activation.ensureValidPendingSequence();
-      this.notify.queueStateChange();
-    });
-  }
-  getReadonlyData() {
-    if (this.state.runtime.readonlyDataVersion === this.state.runtime.dataVersion) {
-      return this.state.runtime.readonlyData;
-    }
-    this.state.runtime.readonlyData = Object.freeze({ ...this.state.runtime.data });
-    this.state.runtime.readonlyDataVersion = this.state.runtime.dataVersion;
-    return this.state.runtime.readonlyData;
-  }
-}
-
-// src/lib/registry.ts
-class CopyOnWriteRegistry {
-  items = [];
-  getItems() {
-    return this.items;
-  }
-  setItems(items) {
-    this.items = items;
-  }
-  removeItem(value) {
-    const current = this.items;
-    if (current.length === 0) {
-      return false;
-    }
-    const next = current.filter((candidate) => candidate !== value);
-    if (next.length === current.length) {
-      return false;
-    }
-    this.items = next;
-    return true;
-  }
-  has() {
-    return this.items.length > 0;
-  }
-  clear() {
-    this.items = [];
-  }
-}
-
-class OrderedRegistry extends CopyOnWriteRegistry {
-  append(value) {
-    this.setItems([...this.getItems(), value]);
-    return () => {
-      this.remove(value);
-    };
-  }
-  prepend(value) {
-    this.setItems([value, ...this.getItems()]);
-    return () => {
-      this.remove(value);
-    };
-  }
-  remove(value) {
-    return this.removeItem(value);
-  }
-  values() {
-    return this.getItems();
-  }
-}
-
-class PriorityRegistry extends CopyOnWriteRegistry {
-  order = 0;
-  register(listener, options) {
-    const registered = { ...options, listener, order: this.order++ };
-    this.setItems([...this.getItems(), registered].sort((left, right) => {
-      const priorityDiff = right.priority - left.priority;
-      if (priorityDiff !== 0) {
-        return priorityDiff;
-      }
-      return left.order - right.order;
-    }));
-    return () => {
-      this.removeItem(registered);
-    };
-  }
-  entries() {
-    return this.getItems();
-  }
-}
-
-// src/services/state.ts
-var EMPTY_DATA = Object.freeze({});
-function createKeymapState() {
-  return {
-    core: {
-      order: 0
-    },
-    environment: {
-      tokens: new Map,
-      layerFields: new Map,
-      bindingExpanders: new OrderedRegistry,
-      bindingParsers: new OrderedRegistry,
-      bindingTransformers: new OrderedRegistry,
-      bindingFields: new Map,
-      commandFields: new Map
-    },
-    dispatch: {
-      eventMatchResolvers: new OrderedRegistry,
-      disambiguationResolvers: new OrderedRegistry,
-      keyHooks: new PriorityRegistry,
-      rawHooks: new PriorityRegistry
-    },
-    layers: {
-      layers: new Set,
-      sortedLayers: [],
-      activeLayersVersion: 0,
-      activeLayersCacheVersion: -1,
-      activeLayersCacheFocused: undefined,
-      activeLayersCache: [],
-      layersWithConditions: 0,
-      layersWithCommands: 0,
-      layerAnalyzers: new OrderedRegistry
-    },
-    commands: {
-      commandMetadataVersion: 0,
-      registeredNames: new Map,
-      commandResolvers: new OrderedRegistry,
-      activeCommandViewVersion: -1,
-      activeCommandView: undefined,
-      registeredCommandViewVersion: -1,
-      registeredCommandView: undefined,
-      registeredCommandEntriesCacheVersion: -1,
-      registeredCommandEntriesCache: []
-    },
-    projection: {
-      pendingSequence: null,
-      pendingSequenceCacheVersion: -1,
-      pendingSequenceCache: [],
-      activeKeysPlainCacheVersion: -1,
-      activeKeysPlainCache: [],
-      activeKeysBindingsCacheVersion: -1,
-      activeKeysBindingsCache: [],
-      activeKeysMetadataCacheVersion: -1,
-      activeKeysMetadataCache: [],
-      activeKeysBindingsAndMetadataCacheVersion: -1,
-      activeKeysBindingsAndMetadataCache: []
-    },
-    conditions: {
-      runtimeKeyDependents: new Map
-    },
-    runtime: {
-      data: {},
-      dataVersion: 0,
-      readonlyDataVersion: -1,
-      readonlyData: EMPTY_DATA
-    },
-    notify: {
-      derivedStateVersion: 0,
-      stateChangeDepth: 0,
-      stateChangePending: false,
-      flushingStateChange: false,
-      usedWarningKeys: new Set
-    }
-  };
-}
-
-// src/keymap.ts
-function getKeyMatchKey(input) {
-  return resolveKeyMatch(input);
-}
-
-class Keymap {
-  host;
-  state = createKeymapState();
-  cleanedUp = false;
-  resources = new Map;
-  cleanupListeners = [];
-  events = new Emitter(() => {});
-  hooks;
-  notify;
-  activation;
-  runtime;
-  conditions;
-  catalog;
-  executor;
-  compiler;
-  dispatch;
-  layers;
-  environment;
-  keypressListener;
-  keyreleaseListener;
-  rawListener;
-  focusedTargetListener;
-  constructor(host) {
-    this.host = host;
-    if (host.isDestroyed) {
-      throw new Error("Cannot create a keymap for a destroyed host");
-    }
-    this.hooks = new Emitter((name, error) => {
-      this.notify.reportListenerError(name, error);
-    });
-    this.notify = new NotificationService(this.state, this.events, this.hooks);
-    this.conditions = new ConditionService(this.state, this.notify);
-    this.catalog = new CommandCatalogService(this.state, this.host, this.notify, this.conditions, {
-      onCommandResolversChanged: () => {
-        this.activation.ensureValidPendingSequence();
-      }
-    });
-    this.activation = new ActivationService(this.state, this.host, this.hooks, this.notify, this.conditions, this.catalog, {
-      onPendingSequenceChanged: (previous, next) => {
-        this.dispatch?.handlePendingSequenceChange(previous, next);
-      }
-    });
-    this.runtime = new RuntimeService(this.state, this.notify, this.conditions, this.activation);
-    this.executor = new CommandExecutorService(this.notify, this.runtime, this.activation, this.catalog, {
-      keymap: this,
-      createCommandEvent: () => this.host.createCommandEvent()
-    });
-    this.compiler = new CompilerService(this.state, this.notify, this.conditions, {
-      warnUnknownField: (kind, fieldName) => {
-        this.warnUnknownField(kind, fieldName);
-      },
-      warnUnknownToken: (token, sequence) => {
-        this.warnUnknownToken(token, sequence);
-      }
-    });
-    this.layers = new LayerService(this.state, this.notify, this.conditions, this.activation, {
-      compiler: this.compiler,
-      commands: this.catalog,
-      host: this.host,
-      warnUnknownField: (kind, fieldName) => {
-        this.warnUnknownField(kind, fieldName);
-      }
-    });
-    this.environment = new EnvironmentService(this.state, this.notify, this.compiler, this.layers);
-    this.dispatch = new DispatchService(this.state, this.notify, this.runtime, this.activation, this.conditions, this.executor, this.compiler, this.catalog, this.layers);
-    this.keypressListener = (event) => {
-      this.dispatch.handleKeyEvent(event, false);
-    };
-    this.keyreleaseListener = (event) => {
-      this.dispatch.handleKeyEvent(event, true);
-    };
-    this.rawListener = (sequence) => {
-      return this.dispatch.handleRawSequence(sequence);
-    };
-    this.focusedTargetListener = (focused) => {
-      this.handleFocusedTargetChange(focused);
-    };
-    this.cleanupListeners.push(this.host.onKeyPress(this.keypressListener));
-    this.cleanupListeners.push(this.host.onKeyRelease(this.keyreleaseListener));
-    if (this.host.onRawInput) {
-      this.cleanupListeners.push(this.host.onRawInput(this.rawListener));
-    }
-    this.cleanupListeners.push(this.host.onFocusChange(this.focusedTargetListener));
-    if (this.host.onDestroy) {
-      this.cleanupListeners.push(this.host.onDestroy(() => {
-        this.cleanup();
-      }));
-    }
-  }
-  cleanup() {
-    if (this.cleanedUp) {
-      return;
-    }
-    this.cleanedUp = true;
-    this.activation.setPendingSequence(null);
-    for (const resource of this.resources.values()) {
-      resource.dispose();
-    }
-    this.resources.clear();
-    this.layers.cleanup();
-    for (const cleanupListener of this.cleanupListeners.splice(0)) {
-      cleanupListener();
-    }
-  }
-  setData(name, value) {
-    this.runtime.setData(name, value);
-  }
-  getData(name) {
-    return this.runtime.getData(name);
-  }
-  hasPendingSequence() {
-    return this.activation.ensureValidPendingSequence() !== undefined;
-  }
-  getPendingSequence() {
-    return this.activation.getPendingSequence();
-  }
-  createKeyMatcher(key) {
-    const match = this.compiler.parseTokenKey(key).match;
-    return (input) => {
-      if (!input) {
-        return false;
-      }
-      return getKeyMatchKey(input) === match;
-    };
-  }
-  clearPendingSequence() {
-    this.activation.setPendingSequence(null);
-  }
-  popPendingSequence() {
-    return this.activation.popPendingSequence();
-  }
-  getActiveKeys(options) {
-    return this.activation.getActiveKeys(options);
-  }
-  getCommands(query) {
-    return this.catalog.getCommands(query);
-  }
-  getCommandEntries(query) {
-    return this.catalog.getCommandEntries(query);
-  }
-  normalizeCommandName(name) {
-    return normalizeCommandName(name);
-  }
-  normalizeBindings(bindings) {
-    return normalizeBindingInputs(bindings);
-  }
-  acquireResource(key, setup) {
-    if (this.cleanedUp || this.host.isDestroyed) {
-      throw new Error("Cannot use a keymap after its host was destroyed");
-    }
-    const existing = this.resources.get(key);
-    if (existing) {
-      existing.count += 1;
-      return () => {
-        this.releaseResource(key, existing);
-      };
-    }
-    const dispose = setup();
-    const resource = { count: 1, dispose };
-    this.resources.set(key, resource);
-    return () => {
-      this.releaseResource(key, resource);
-    };
-  }
-  runCommand(cmd, options) {
-    return this.executor.runCommand(cmd, options);
-  }
-  dispatchCommand(cmd, options) {
-    return this.executor.dispatchCommand(cmd, options);
-  }
-  on(name, fn) {
-    if (name === "warning") {
-      return this.events.hook(name, fn);
-    }
-    if (name === "error") {
-      return this.events.hook(name, fn);
-    }
-    return this.hooks.hook(name, fn);
-  }
-  intercept(name, fn, options) {
-    if (name === "key") {
-      return this.dispatch.intercept(name, fn, options);
-    }
-    return this.dispatch.intercept(name, fn, options);
-  }
-  registerLayer(layer) {
-    return this.layers.registerLayer(layer);
-  }
-  registerLayerFields(fields) {
-    return this.environment.registerLayerFields(fields);
-  }
-  prependBindingTransformer(transformer) {
-    return this.environment.prependBindingTransformer(transformer);
-  }
-  appendBindingTransformer(transformer) {
-    return this.environment.appendBindingTransformer(transformer);
-  }
-  clearBindingTransformers() {
-    this.environment.clearBindingTransformers();
-  }
-  prependBindingParser(parser) {
-    return this.environment.prependBindingParser(parser);
-  }
-  appendBindingParser(parser) {
-    return this.environment.appendBindingParser(parser);
-  }
-  clearBindingParsers() {
-    this.environment.clearBindingParsers();
-  }
-  registerToken(token) {
-    return this.environment.registerToken(token);
-  }
-  prependBindingExpander(expander) {
-    return this.environment.prependBindingExpander(expander);
-  }
-  appendBindingExpander(expander) {
-    return this.environment.appendBindingExpander(expander);
-  }
-  clearBindingExpanders() {
-    this.environment.clearBindingExpanders();
-  }
-  registerBindingFields(fields) {
-    return this.environment.registerBindingFields(fields);
-  }
-  registerCommandFields(fields) {
-    return this.environment.registerCommandFields(fields);
-  }
-  prependCommandResolver(resolver) {
-    return this.catalog.prependCommandResolver(resolver);
-  }
-  appendCommandResolver(resolver) {
-    return this.catalog.appendCommandResolver(resolver);
-  }
-  clearCommandResolvers() {
-    this.catalog.clearCommandResolvers();
-  }
-  prependLayerAnalyzer(analyzer) {
-    return this.layers.prependLayerAnalyzer(analyzer);
-  }
-  appendLayerAnalyzer(analyzer) {
-    return this.layers.appendLayerAnalyzer(analyzer);
-  }
-  clearLayerAnalyzers() {
-    this.layers.clearLayerAnalyzers();
-  }
-  prependEventMatchResolver(resolver) {
-    return this.dispatch.prependEventMatchResolver(resolver);
-  }
-  appendEventMatchResolver(resolver) {
-    return this.dispatch.appendEventMatchResolver(resolver);
-  }
-  clearEventMatchResolvers() {
-    this.dispatch.clearEventMatchResolvers();
-  }
-  prependDisambiguationResolver(resolver) {
-    return this.dispatch.prependDisambiguationResolver(resolver);
-  }
-  appendDisambiguationResolver(resolver) {
-    return this.dispatch.appendDisambiguationResolver(resolver);
-  }
-  clearDisambiguationResolvers() {
-    this.dispatch.clearDisambiguationResolvers();
-  }
-  handleFocusedTargetChange(_focused) {
-    this.notify.runWithStateChangeBatch(() => {
-      this.activation.setPendingSequence(null);
-      this.activation.invalidateActiveLayers();
-      this.activation.refreshActiveLayers(_focused);
-      this.notify.queueStateChange();
-    });
-  }
-  warnUnknownField(kind, fieldName) {
-    this.notify.warnOnce(`${kind}:${fieldName}`, `unknown-${kind}-field`, { field: fieldName, kind }, `[Keymap] Unknown ${kind} field "${fieldName}" was ignored`);
-  }
-  warnUnknownToken(token, sequence) {
-    this.notify.warnOnce(`token:${token}`, "unknown-token", { token, sequence }, `[Keymap] Unknown token "${token}" in key sequence "${sequence}" was ignored`);
-  }
-  releaseResource(key, resource) {
-    const current = this.resources.get(key);
-    if (current !== resource) {
-      return;
-    }
-    resource.count -= 1;
-    if (resource.count > 0) {
-      return;
-    }
-    resource.dispose();
-    this.resources.delete(key);
-  }
-}
-export {
-  stringifyKeyStroke,
-  stringifyKeySequence,
-  Keymap
-};