keystra 0.0.0-stage → 0.1.0

package/dist/chunk-U7YK6PPT.js

@@ -0,0 +1,1729 @@
+import { createSequentialStrategy, createDirectionalStrategy, createGridStrategy } from './chunk-XFNYIPOW.js';
+import { FocusManager } from './chunk-ZOJRXXQN.js';
+import { SelectionManager } from './chunk-SSIKGDD4.js';
+import { LayoutCache, Emitter } from './chunk-S5YVXIMA.js';
+import { queryItems, isDisabled, isHidden, getText, resolveElement, resolveEventTarget, contains, isEditableTarget } from './chunk-77GGU3AX.js';
+
+// src/core/default-keys.ts
+var NAVIGATION = {
+  first: ["Home"],
+  last: ["End"],
+  pageUp: ["PageUp"],
+  pageDown: ["PageDown"],
+  escape: ["Escape"],
+  selectAll: ["Ctrl+A", "Meta+A"]
+};
+var VERTICAL_KEYS = {
+  up: ["ArrowUp"],
+  down: ["ArrowDown"],
+  next: ["ArrowDown"],
+  previous: ["ArrowUp"],
+  toggle: ["Space"],
+  select: ["Enter", "Space"],
+  ...NAVIGATION
+};
+var HORIZONTAL_KEYS = {
+  left: ["ArrowLeft"],
+  right: ["ArrowRight"],
+  next: ["ArrowRight"],
+  previous: ["ArrowLeft"],
+  toggle: ["Space"],
+  select: ["Enter", "Space"],
+  ...NAVIGATION
+};
+var ROVING_KEYS = {
+  up: ["ArrowUp"],
+  down: ["ArrowDown"],
+  left: ["ArrowLeft"],
+  right: ["ArrowRight"],
+  next: ["ArrowDown", "ArrowRight"],
+  previous: ["ArrowUp", "ArrowLeft"],
+  toggle: ["Space"],
+  select: ["Enter", "Space"],
+  ...NAVIGATION
+};
+var TABS_KEYS_HORIZONTAL = {
+  left: ["ArrowLeft"],
+  right: ["ArrowRight"],
+  next: ["ArrowRight"],
+  previous: ["ArrowLeft"],
+  first: ["Home"],
+  last: ["End"],
+  select: ["Enter", "Space"],
+  escape: ["Escape"]
+};
+var TABS_KEYS_VERTICAL = {
+  up: ["ArrowUp"],
+  down: ["ArrowDown"],
+  next: ["ArrowDown"],
+  previous: ["ArrowUp"],
+  first: ["Home"],
+  last: ["End"],
+  select: ["Enter", "Space"],
+  escape: ["Escape"]
+};
+var GRID_KEYS = {
+  up: ["ArrowUp"],
+  down: ["ArrowDown"],
+  left: ["ArrowLeft"],
+  right: ["ArrowRight"],
+  next: ["ArrowDown"],
+  previous: ["ArrowUp"],
+  first: ["Home"],
+  last: ["End"],
+  pageUp: ["PageUp"],
+  pageDown: ["PageDown"],
+  select: ["Enter", "Space"],
+  escape: ["Escape"]
+};
+var MENU_KEYS = {
+  up: ["ArrowUp"],
+  down: ["ArrowDown"],
+  next: ["ArrowDown"],
+  previous: ["ArrowUp"],
+  first: ["Home"],
+  last: ["End"],
+  select: ["Enter", "Space"],
+  escape: ["Escape"]
+};
+var TREE_KEYS = {
+  up: ["ArrowUp"],
+  down: ["ArrowDown"],
+  next: ["ArrowDown"],
+  previous: ["ArrowUp"],
+  expand: ["ArrowRight"],
+  collapse: ["ArrowLeft"],
+  first: ["Home"],
+  last: ["End"],
+  select: ["Enter", "Space"],
+  escape: ["Escape"]
+};
+var LIST_KEYS = {
+  up: ["ArrowUp"],
+  down: ["ArrowDown"],
+  next: ["ArrowDown"],
+  previous: ["ArrowUp"],
+  first: ["Home"],
+  last: ["End"],
+  pageUp: ["PageUp"],
+  pageDown: ["PageDown"],
+  toggle: ["Space"],
+  select: ["Enter"],
+  selectAll: ["Ctrl+A", "Meta+A"],
+  escape: ["Escape"]
+};
+var COMMAND_PALETTE_KEYS = {
+  up: ["ArrowUp"],
+  down: ["ArrowDown"],
+  next: ["ArrowDown"],
+  previous: ["ArrowUp"],
+  pageUp: ["PageUp"],
+  pageDown: ["PageDown"],
+  select: ["Enter"],
+  escape: ["Escape"]
+};
+function defaultKeysFor(mode) {
+  switch (mode) {
+    case "horizontal":
+      return HORIZONTAL_KEYS;
+    case "grid":
+    case "directional":
+      return GRID_KEYS;
+    case "sequential":
+    case "vertical":
+    case "custom":
+    default:
+      return VERTICAL_KEYS;
+  }
+}
+function mergeKeys(defaults, user, useDefaults) {
+  if (!useDefaults) return { ...user ?? {} };
+  const merged = { ...defaults };
+  if (user) {
+    for (const action of Object.keys(user)) {
+      const value = user[action];
+      if (value === void 0) continue;
+      if (value === false || value === null) delete merged[action];
+      else merged[action] = value;
+    }
+  }
+  return merged;
+}
+
+// src/core/event-manager.ts
+var EventManager = class {
+  constructor() {
+    this.records = [];
+  }
+  add(target, type, listener, options) {
+    if (!target || typeof target.addEventListener !== "function") return () => {
+    };
+    target.addEventListener(type, listener, options);
+    const record = { target, type, listener, options: options ?? false };
+    this.records.push(record);
+    return () => this.removeRecord(record);
+  }
+  removeRecord(record) {
+    const index = this.records.indexOf(record);
+    if (index === -1) return;
+    this.records.splice(index, 1);
+    record.target.removeEventListener(record.type, record.listener, record.options);
+  }
+  dispose() {
+    for (let i = this.records.length - 1; i >= 0; i--) {
+      const record = this.records[i];
+      record.target.removeEventListener(record.type, record.listener, record.options);
+    }
+    this.records.length = 0;
+  }
+  get count() {
+    return this.records.length;
+  }
+};
+function createRafThrottle(callback) {
+  let queued = false;
+  const raf = typeof globalThis.requestAnimationFrame === "function" ? globalThis.requestAnimationFrame.bind(globalThis) : (fn) => setTimeout(fn, 16);
+  const cancelRaf = typeof globalThis.cancelAnimationFrame === "function" ? globalThis.cancelAnimationFrame.bind(globalThis) : (id) => clearTimeout(id);
+  let handle = null;
+  return {
+    schedule() {
+      if (queued) return;
+      queued = true;
+      handle = raf(() => {
+        queued = false;
+        handle = null;
+        callback();
+      });
+    },
+    cancel() {
+      if (handle !== null) cancelRaf(handle);
+      handle = null;
+      queued = false;
+    }
+  };
+}
+
+// src/core/item-collection.ts
+var groups = /* @__PURE__ */ new Map();
+function claimGroup(container) {
+  if (container) groups.set(container, (groups.get(container) ?? 0) + 1);
+}
+function releaseGroup(container) {
+  if (!container) return;
+  const count = groups.get(container) ?? 0;
+  if (count <= 1) groups.delete(container);
+  else groups.set(container, count - 1);
+}
+function groupsInside(container) {
+  const inside = [];
+  if (!container) return inside;
+  for (const group of groups.keys()) {
+    if (group !== container && container.contains(group)) inside.push(group);
+  }
+  return inside;
+}
+var ItemCollection = class {
+  constructor(container, options, onInvalidate) {
+    this.container = container;
+    this.options = options;
+    this.onInvalidate = onInvalidate;
+    this.list = [];
+    this.extra = [];
+    this.removed = /* @__PURE__ */ new WeakSet();
+    this.explicit = null;
+    this.built = false;
+    this.observer = null;
+    this.observerKey = "";
+    this.layout = new LayoutCache();
+    this._version = 0;
+    claimGroup(container);
+  }
+  get version() {
+    return this._version;
+  }
+  get items() {
+    if (!this.built) this.build();
+    return this.list;
+  }
+  get size() {
+    return this.items.length;
+  }
+  setContainer(container) {
+    if (this.container === container) return;
+    releaseGroup(this.container);
+    claimGroup(container);
+    this.container = container;
+    this.invalidate();
+  }
+  setItems(elements) {
+    this.explicit = elements ? elements.slice() : null;
+    this.invalidate();
+  }
+  add(element) {
+    const additions = Array.isArray(element) ? element : [element];
+    for (const item of additions) {
+      if (!item || this.extra.includes(item)) continue;
+      this.removed.delete(item);
+      this.extra.push(item);
+    }
+    this.invalidate();
+  }
+  remove(element) {
+    const removals = Array.isArray(element) ? element : [element];
+    for (const item of removals) {
+      const index = this.extra.indexOf(item);
+      if (index !== -1) this.extra.splice(index, 1);
+      this.removed.add(item);
+    }
+    this.invalidate();
+  }
+  invalidate() {
+    this.built = false;
+    this.onInvalidate?.();
+  }
+  refresh() {
+    this.build();
+    return this.list;
+  }
+  revalidate() {
+    if (this.observer) return;
+    const before = this.list;
+    this.build();
+    if (this.list !== before) this.onInvalidate?.();
+  }
+  indexOf(element) {
+    if (!element) return -1;
+    return this.items.indexOf(element);
+  }
+  at(index) {
+    return this.items[index] ?? null;
+  }
+  startObserving() {
+    if (!this.options.observe) {
+      this.stopObserving();
+      return;
+    }
+    const key = `${this.container ? "c" : "n"}:${JSON.stringify(this.options.observe)}`;
+    if (this.observer && this.observerKey === key) return;
+    this.stopObserving();
+    if (!this.container || typeof MutationObserver !== "function") return;
+    const init = typeof this.options.observe === "object" ? this.options.observe : { childList: true, subtree: true, attributes: true, attributeFilter: ["disabled", "aria-disabled", "hidden", "style", "class"] };
+    this.observer = new MutationObserver(() => this.invalidate());
+    this.observer.observe(this.container, init);
+    this.observerKey = key;
+  }
+  stopObserving() {
+    if (this.observer) {
+      this.observer.disconnect();
+      this.observer = null;
+      this.observerKey = "";
+    }
+  }
+  dispose() {
+    this.stopObserving();
+    releaseGroup(this.container);
+    this.list = [];
+    this.extra = [];
+    this.removed = /* @__PURE__ */ new WeakSet();
+    this.explicit = null;
+    this.built = false;
+    this.container = null;
+    this.onInvalidate = void 0;
+  }
+  build() {
+    const { selector, disabledSelector, skipHidden, filter } = this.options;
+    let source;
+    let nested = [];
+    if (this.explicit) {
+      source = this.explicit.slice();
+    } else {
+      source = queryItems(this.container, selector);
+      nested = groupsInside(this.container);
+      if (this.extra.length > 0) {
+        const merged = source.slice();
+        for (const item of this.extra) if (!merged.includes(item)) merged.push(item);
+        source = sortInDomOrder(merged);
+      }
+    }
+    const result = [];
+    for (let i = 0; i < source.length; i++) {
+      const element = source[i];
+      if (!element || this.removed.has(element)) continue;
+      if (nested.length > 0 && nested.some((group) => group !== element && group.contains(element))) continue;
+      if (disabledSelector && isDisabled(element, disabledSelector)) continue;
+      if (skipHidden && isHidden(element)) continue;
+      if (filter && !filter(element, result.length)) continue;
+      result.push(element);
+    }
+    if (sameList(this.list, result)) {
+      this.built = true;
+      this.startObserving();
+      return;
+    }
+    this._version++;
+    this.list = result;
+    this.built = true;
+    this.startObserving();
+  }
+};
+function sameList(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+function sortInDomOrder(elements) {
+  if (elements.length < 2) return elements;
+  if (typeof document === "undefined" || elements[0]?.compareDocumentPosition == null) return elements;
+  return elements.slice().sort((a, b) => {
+    if (a === b) return 0;
+    const position = a.compareDocumentPosition(b);
+    if (position & Node.DOCUMENT_POSITION_FOLLOWING) return -1;
+    if (position & Node.DOCUMENT_POSITION_PRECEDING) return 1;
+    return 0;
+  });
+}
+function createRectOf(collection) {
+  return (element) => collection.layout.rect(element, collection.version);
+}
+
+// src/core/keyboard.ts
+var KEY_ALIASES = {
+  spacebar: "Space",
+  " ": "Space",
+  esc: "Escape",
+  del: "Delete",
+  left: "ArrowLeft",
+  right: "ArrowRight",
+  up: "ArrowUp",
+  down: "ArrowDown",
+  multiply: "*",
+  add: "+",
+  subtract: "-",
+  divide: "/",
+  decimal: ".",
+  windows: "Meta",
+  cmd: "Meta",
+  command: "Meta",
+  option: "Alt",
+  control: "Control",
+  return: "Enter",
+  cr: "Enter",
+  pageup: "PageUp",
+  pagedown: "PageDown",
+  "page up": "PageUp",
+  "page down": "PageDown"
+};
+var CANONICAL = /* @__PURE__ */ new Set([
+  "arrowup",
+  "arrowdown",
+  "arrowleft",
+  "arrowright",
+  "enter",
+  "escape",
+  "tab",
+  "space",
+  "home",
+  "end",
+  "pageup",
+  "pagedown",
+  "backspace",
+  "delete",
+  "insert",
+  "shift",
+  "control",
+  "alt",
+  "meta",
+  "capslock",
+  "contextmenu",
+  "f1",
+  "f2",
+  "f3",
+  "f4",
+  "f5",
+  "f6",
+  "f7",
+  "f8",
+  "f9",
+  "f10",
+  "f11",
+  "f12",
+  "f13",
+  "f14",
+  "f15",
+  "f16",
+  "f17",
+  "f18",
+  "f19",
+  "f20",
+  "f21",
+  "f22",
+  "f23",
+  "f24",
+  "printscreen",
+  "scrolllock",
+  "pause",
+  "unidentified"
+]);
+function normalizeKeyName(key) {
+  if (!key) return "";
+  const lower = key.toLowerCase();
+  const alias = KEY_ALIASES[lower];
+  if (alias !== void 0) return alias;
+  if (key.length === 1) return key;
+  if (CANONICAL.has(lower)) return canonicalCase(lower);
+  return key;
+}
+function canonicalCase(lower) {
+  switch (lower) {
+    case "arrowup":
+      return "ArrowUp";
+    case "arrowdown":
+      return "ArrowDown";
+    case "arrowleft":
+      return "ArrowLeft";
+    case "arrowright":
+      return "ArrowRight";
+    case "pageup":
+      return "PageUp";
+    case "pagedown":
+      return "PageDown";
+    case "capslock":
+      return "CapsLock";
+    case "contextmenu":
+      return "ContextMenu";
+    case "printscreen":
+      return "PrintScreen";
+    case "scrolllock":
+      return "ScrollLock";
+    case "unidentified":
+      return "Unidentified";
+    default:
+      return lower.charAt(0).toUpperCase() + lower.slice(1);
+  }
+}
+var NON_PRINTABLE = /* @__PURE__ */ new Set([
+  "Shift",
+  "Control",
+  "Alt",
+  "Meta",
+  "CapsLock",
+  "Tab",
+  "Enter",
+  "Escape",
+  "Backspace",
+  "Delete",
+  "Insert",
+  "Home",
+  "End",
+  "PageUp",
+  "PageDown",
+  "ArrowUp",
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight",
+  "ContextMenu",
+  "PrintScreen",
+  "ScrollLock",
+  "Pause",
+  "Unidentified"
+]);
+function isPrintableKey(key) {
+  if (!key) return false;
+  if (key.length === 1) return true;
+  if (NON_PRINTABLE.has(key)) return false;
+  if (/^F\d{1,2}$/.test(key)) return false;
+  if (/^(Numpad|NumLock)/.test(key)) return false;
+  return false;
+}
+function isModifierKey(key) {
+  return key === "Shift" || key === "Control" || key === "Alt" || key === "Meta";
+}
+function normalizeKeyEvent(event) {
+  let key = normalizeKeyName(event.key ?? "");
+  if (key === "Unidentified" || key === "") {
+    const fromCode = codeToKey(event.code);
+    if (fromCode) key = fromCode;
+  }
+  const ctrl = event.ctrlKey === true;
+  const alt = event.altKey === true;
+  const shift = event.shiftKey === true;
+  const meta = event.metaKey === true;
+  return {
+    key,
+    code: event.code ?? "",
+    ctrl,
+    alt,
+    shift,
+    meta,
+    isPlain: !ctrl && !alt && !meta,
+    isPrintable: isPrintableKey(key) && !ctrl && !alt && !meta,
+    repeat: event.repeat === true,
+    shiftKey: shift,
+    originalEvent: event
+  };
+}
+function codeToKey(code) {
+  if (!code) return "";
+  if (code.startsWith("Key")) return code.slice(3);
+  if (code.startsWith("Digit")) return code.slice(5);
+  if (code.startsWith("Arrow")) return code;
+  if (code === "NumpadEnter") return "Enter";
+  if (code.startsWith("Numpad")) {
+    const rest = code.slice(6);
+    if (/^\d$/.test(rest)) return rest;
+    if (rest === "Add") return "+";
+    if (rest === "Subtract") return "-";
+    if (rest === "Multiply") return "*";
+    if (rest === "Divide") return "/";
+    if (rest === "Decimal") return ".";
+    return `Numpad${rest}`;
+  }
+  switch (code) {
+    case "Space":
+      return "Space";
+    case "Enter":
+    case "NumpadEnter":
+      return "Enter";
+    case "Escape":
+      return "Escape";
+    case "Tab":
+      return "Tab";
+    case "Backspace":
+      return "Backspace";
+    case "Delete":
+      return "Delete";
+    case "Minus":
+      return "-";
+    case "Equal":
+      return "=";
+    case "Comma":
+      return ",";
+    case "Period":
+      return ".";
+    case "Slash":
+      return "/";
+    case "Backslash":
+      return "\\";
+    case "Semicolon":
+      return ";";
+    case "Quote":
+      return "'";
+    case "BracketLeft":
+      return "[";
+    case "BracketRight":
+      return "]";
+    case "Backquote":
+      return "`";
+    default:
+      return "";
+  }
+}
+function formatKeyCombo(key, modifiers = {}) {
+  const parts = [];
+  if (modifiers.ctrl) parts.push("Ctrl");
+  if (modifiers.alt) parts.push("Alt");
+  if (modifiers.shift) parts.push("Shift");
+  if (modifiers.meta) parts.push("Meta");
+  if (key) parts.push(key);
+  return parts.join("+");
+}
+function describeEvent(event) {
+  const normalized = normalizeKeyEvent(event);
+  return formatKeyCombo(normalized.key, normalized);
+}
+
+// src/core/key-matcher.ts
+var MODIFIER_ALIASES = {
+  ctrl: "ctrl",
+  ctl: "ctrl",
+  control: "ctrl",
+  alt: "alt",
+  option: "alt",
+  opt: "alt",
+  shift: "shift",
+  meta: "meta",
+  cmd: "meta",
+  command: "meta",
+  super: "meta",
+  win: "meta",
+  windows: "meta"
+};
+function tokenize(chord) {
+  const tokens = [];
+  let current = "";
+  let quoted = false;
+  for (let i = 0; i < chord.length; i++) {
+    const char = chord[i];
+    if (char === '"' || char === "'") {
+      quoted = !quoted;
+      continue;
+    }
+    if (char === "+" && !quoted) {
+      if (i === chord.length - 1) {
+        tokens.push("+");
+        current = "";
+        continue;
+      }
+      if (current !== "") tokens.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current !== "") tokens.push(current);
+  return tokens;
+}
+function parseKeyBinding(binding) {
+  if (binding == null) return null;
+  let key = null;
+  let code = null;
+  let ctrl = false;
+  let alt = false;
+  let shift = false;
+  let meta = false;
+  let allowWithoutModifiers = false;
+  if (typeof binding === "object") {
+    if (binding.key) key = normalizeKeyName(String(binding.key));
+    if (binding.code) code = String(binding.code);
+    ctrl = binding.ctrl === true;
+    alt = binding.alt === true;
+    shift = binding.shift === true;
+    meta = binding.meta === true;
+    allowWithoutModifiers = binding.allowWithoutModifiers === true;
+    if (!key && !code) return null;
+  } else {
+    const raw = String(binding);
+    const trimmed = raw.trim();
+    if (trimmed === "" && raw !== " ") return null;
+    const chord = raw === " " ? " " : trimmed;
+    if (!chord) return null;
+    const tokens = tokenize(chord);
+    if (tokens.length === 0) return null;
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+      const modifier = MODIFIER_ALIASES[token.toLowerCase()];
+      if (modifier && i < tokens.length - 1) {
+        if (modifier === "ctrl") ctrl = true;
+        else if (modifier === "alt") alt = true;
+        else if (modifier === "shift") shift = true;
+        else meta = true;
+        continue;
+      }
+      key = normalizeKeyName(token);
+    }
+    if (!key) return null;
+    if (shift && key.length === 1) key = key.toLowerCase();
+  }
+  return {
+    key,
+    code,
+    ctrl,
+    alt,
+    shift,
+    meta,
+    allowWithoutModifiers,
+    id: bindingId(key, code, ctrl, alt, shift, meta)
+  };
+}
+function bindingId(key, code, ctrl, alt, shift, meta) {
+  const flags = (ctrl ? "c" : "") + (alt ? "a" : "") + (shift ? "s" : "") + (meta ? "m" : "");
+  const main = code ? `#${code.toLowerCase()}` : (key ?? "").toLowerCase();
+  return flags ? `${flags}:${main}` : main;
+}
+function toArray(input) {
+  if (input == null || input === false) return [];
+  return Array.isArray(input) ? input : [input];
+}
+var KeyMatcher = class {
+  constructor(map = {}, sequences = []) {
+    this.byId = /* @__PURE__ */ new Map();
+    this.loose = [];
+    this.actions = /* @__PURE__ */ new Set();
+    this.sequences = [];
+    this.sequenceIndex = 0;
+    this.sequenceOwner = null;
+    this.sequenceTimer = null;
+    this.sequenceCandidates = [];
+    this.loadMap(map);
+    this.loadSequences(sequences);
+  }
+  loadMap(map) {
+    this.byId.clear();
+    this.loose.length = 0;
+    this.actions.clear();
+    for (const action of Object.keys(map)) {
+      for (const raw of toArray(map[action])) {
+        const binding = parseKeyBinding(raw);
+        if (!binding) continue;
+        this.actions.add(action);
+        let entry = this.byId.get(binding.id);
+        if (!entry || entry.binding.id !== binding.id) {
+          entry = { actions: [], binding };
+          this.byId.set(binding.id, entry);
+          if (binding.allowWithoutModifiers || binding.code) this.loose.push(entry);
+        }
+        if (entry.actions.indexOf(action) === -1) entry.actions.push(action);
+      }
+    }
+  }
+  loadSequences(sequences) {
+    this.resetSequence();
+    this.sequences.length = 0;
+    for (const options of sequences) {
+      const normalized = normalizeSequence(options);
+      if (!normalized) continue;
+      const steps = [];
+      let valid = true;
+      for (const raw of normalized.binding) {
+        const parsed = parseKeyBinding(raw);
+        if (!parsed) {
+          valid = false;
+          break;
+        }
+        steps.push(parsed);
+      }
+      if (!valid) continue;
+      this.sequences.push({
+        steps,
+        action: normalized.action,
+        timeout: normalized.timeout ?? 1e3,
+        preventDefault: normalized.preventDefault !== false
+      });
+    }
+  }
+  has(action) {
+    return this.actions.has(action);
+  }
+  get boundActions() {
+    return Array.from(this.actions);
+  }
+  get size() {
+    return this.byId.size + this.sequences.length;
+  }
+  match(event, owner) {
+    if (this.sequences.length > 0) {
+      const sequence = this.matchSequence(event, owner);
+      if (sequence) return sequence;
+    }
+    const ids = candidateIds(event);
+    for (let i = 0; i < ids.length; i++) {
+      const entry = this.byId.get(ids[i]);
+      if (entry && matchesBinding(entry.binding, event)) {
+        return { actions: entry.actions, binding: entry.binding, fromSequence: false, complete: true, preventDefault: true };
+      }
+    }
+    for (let i = 0; i < this.loose.length; i++) {
+      const entry = this.loose[i];
+      if (matchesBinding(entry.binding, event)) {
+        return { actions: entry.actions, binding: entry.binding, fromSequence: false, complete: true, preventDefault: true };
+      }
+    }
+    return null;
+  }
+  resetSequence() {
+    this.sequenceIndex = 0;
+    this.sequenceCandidates = [];
+    this.clearSequenceTimer();
+  }
+  dispose() {
+    this.resetSequence();
+    this.byId.clear();
+    this.loose.length = 0;
+    this.actions.clear();
+    this.sequences.length = 0;
+  }
+  matchSequence(event, owner) {
+    if (owner && this.sequenceOwner && this.sequenceOwner !== owner) this.resetSequence();
+    if (owner) this.sequenceOwner = owner;
+    const pending = this.sequenceCandidates.length > 0;
+    const step = this.sequenceIndex;
+    const pool = pending ? this.sequenceCandidates : this.sequences;
+    const fitting = pool.filter((sequence) => {
+      const binding = sequence.steps[step];
+      return binding !== void 0 && matchesBinding(binding, event);
+    });
+    if (fitting.length === 0) {
+      if (!pending) return null;
+      this.resetSequence();
+      return this.matchSequence(event, owner);
+    }
+    const done = fitting.find((sequence) => sequence.steps.length === step + 1);
+    const lead = done ?? fitting[0];
+    const result = {
+      actions: [lead.action],
+      binding: lead.steps[step],
+      fromSequence: true,
+      complete: done !== void 0,
+      preventDefault: lead.preventDefault
+    };
+    if (done) {
+      this.resetSequence();
+    } else {
+      this.sequenceCandidates = fitting;
+      this.sequenceIndex = step + 1;
+      this.armSequenceTimer(lead.timeout);
+    }
+    return result;
+  }
+  armSequenceTimer(timeout) {
+    this.clearSequenceTimer();
+    if (typeof setTimeout !== "function") return;
+    this.sequenceTimer = setTimeout(() => this.resetSequence(), timeout);
+  }
+  clearSequenceTimer() {
+    if (this.sequenceTimer !== null) {
+      clearTimeout(this.sequenceTimer);
+      this.sequenceTimer = null;
+    }
+  }
+};
+var SHIFT_DISTINCT_KEYS = /* @__PURE__ */ new Set(["tab"]);
+function shiftDistinct(key) {
+  return SHIFT_DISTINCT_KEYS.has(key.toLowerCase());
+}
+function makeId(key, ctrl, alt, shift, meta) {
+  const flags = (ctrl ? "c" : "") + (alt ? "a" : "") + (shift ? "s" : "") + (meta ? "m" : "");
+  return flags ? `${flags}:${key}` : key;
+}
+function candidateIds(event) {
+  const { ctrl, alt, shift, meta } = event;
+  const key = event.key;
+  const lower = key.toLowerCase();
+  const ids = [makeId(lower, ctrl, alt, shift, meta)];
+  const singleChar = key.length === 1;
+  const noShift = shift && (singleChar || !shiftDistinct(lower)) ? makeId(lower, ctrl, alt, false, meta) : null;
+  if (noShift) ids.push(noShift);
+  if (singleChar && lower !== key) {
+    ids.push(makeId(key, ctrl, alt, shift, meta));
+    if (noShift) ids.push(makeId(key, ctrl, alt, false, meta));
+  }
+  return ids;
+}
+function matchesBinding(binding, event) {
+  if (binding.code) {
+    if (binding.code.toLowerCase() !== event.code.toLowerCase()) return false;
+  } else if (binding.key) {
+    if (!keyEquals(binding.key, event.key)) return false;
+  } else {
+    return false;
+  }
+  if (binding.allowWithoutModifiers && !event.ctrl && !event.alt && !event.meta) return true;
+  if (binding.ctrl !== event.ctrl) return false;
+  if (binding.alt !== event.alt) return false;
+  if (binding.meta !== event.meta) return false;
+  if (binding.shift !== event.shift) {
+    const named = binding.key ?? "";
+    const singleChar = named.length === 1;
+    if (event.shift && !binding.shift) {
+      if (shiftDistinct(named)) return false;
+      if (/^[a-z]$/i.test(named) && (event.ctrl || event.alt || event.meta)) return false;
+    } else {
+      if (!singleChar) return false;
+    }
+  }
+  return true;
+}
+function keyEquals(bindingKey, eventKey) {
+  if (bindingKey === eventKey) return true;
+  return bindingKey.toLowerCase() === eventKey.toLowerCase();
+}
+function normalizeSequence(input) {
+  if (!input || !input.binding || input.binding.length < 2 || !input.action) return null;
+  return input;
+}
+function createKeyMatcher(map = {}, sequences = []) {
+  return new KeyMatcher(map, sequences);
+}
+
+// src/core/typeahead.ts
+function createTypeahead(options = {}) {
+  const resetDelay = options.resetDelay ?? 600;
+  const getTextFor = options.getText ?? ((element) => getText(element));
+  let buffer = "";
+  let timer = null;
+  let lastMatch = -1;
+  function clearTimer() {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function reset() {
+    buffer = "";
+    lastMatch = -1;
+    clearTimer();
+  }
+  return {
+    get query() {
+      return buffer;
+    },
+    reset,
+    dispose: reset,
+    handle(character, items, currentIndex) {
+      if (!character) return null;
+      const total = items.length;
+      if (total === 0) return null;
+      const previousBuffer = buffer;
+      buffer += character.toLowerCase();
+      if (buffer.length > 12) buffer = buffer.slice(-12);
+      clearTimer();
+      if (typeof setTimeout === "function") timer = setTimeout(reset, resetDelay);
+      const repeating = buffer.length > 1 && previousBuffer.length === 1 && buffer === previousBuffer + previousBuffer;
+      let query = repeating ? previousBuffer : buffer;
+      const collect = (prefix) => {
+        const found = [];
+        for (let i = 0; i < total; i++) {
+          const text = getTextFor(items[i]);
+          if (text && text.toLowerCase().startsWith(prefix)) found.push(i);
+        }
+        return found;
+      };
+      let matches = collect(query);
+      if (matches.length === 0 && query.length > 1) {
+        query = character.toLowerCase();
+        buffer = query;
+        matches = collect(query);
+      }
+      if (matches.length === 0) {
+        options.onMatch?.(null, query);
+        return null;
+      }
+      let pick;
+      if (repeating) {
+        const position = matches.indexOf(lastMatch);
+        pick = matches[(position + 1) % matches.length];
+      } else if (query === previousBuffer && previousBuffer.length > 0) {
+        const position = matches.indexOf(lastMatch);
+        pick = matches[(position + 1) % matches.length];
+      } else {
+        pick = matches[0];
+        for (let i = 0; i < matches.length; i++) {
+          if (matches[i] > currentIndex) {
+            pick = matches[i];
+            break;
+          }
+        }
+      }
+      lastMatch = pick;
+      const element = items[pick] ?? null;
+      options.onMatch?.(element, query);
+      return element;
+    }
+  };
+}
+
+// src/core/engine.ts
+var DEFAULT_ITEM_SELECTOR = "[data-keystra-item]";
+var DEFAULT_DISABLED_SELECTOR = "[disabled],[aria-disabled='true']";
+var DEFAULT_PAGE_SIZE = 10;
+var MOVEMENT_ACTIONS = /* @__PURE__ */ new Set([
+  "next",
+  "previous",
+  "up",
+  "down",
+  "left",
+  "right",
+  "first",
+  "last",
+  "pageUp",
+  "pageDown"
+]);
+function resolveOptions(options = {}, overrides = {}) {
+  const mode = overrides.mode ?? options.mode ?? "vertical";
+  const container = overrides.container ?? resolveElement(options.container) ?? null;
+  const keys = overrides.keys ?? mergeKeys(
+    overrides.defaultKeys ?? defaultKeysFor(mode),
+    options.keys,
+    options.useDefaultKeys !== false
+  );
+  const userStrategy = options.strategy ?? null;
+  const listenTarget = overrides.listenTarget ?? resolveEventTarget(options.target) ?? container ?? (typeof document !== "undefined" ? document : null);
+  const resolved = {
+    container,
+    pinnedTarget: options.target !== void 0 && options.target !== null,
+    listenTarget,
+    selector: options.items ?? options.itemSelector ?? DEFAULT_ITEM_SELECTOR,
+    disabledSelector: options.disabledSelector === false || options.disabledSelector === null ? null : options.disabledSelector ?? DEFAULT_DISABLED_SELECTOR,
+    skipHidden: options.skipHidden !== false,
+    filter: options.filter ?? null,
+    mode,
+    loop: overrides.loop ?? options.loop === true,
+    columns: overrides.columns ?? options.columns ?? 0,
+    pageSize: options.pageSize ?? DEFAULT_PAGE_SIZE,
+    strategy: userStrategy ?? overrides.strategy ?? strategyForMode(mode),
+    userStrategy,
+    onBeforeNavigate: options.onBeforeNavigate ?? null,
+    keys,
+    defaultKeys: overrides.defaultKeys ?? null,
+    userKeys: options.keys ?? null,
+    useDefaultKeys: options.useDefaultKeys !== false,
+    sequences: options.sequences ?? [],
+    typeahead: normalizeTypeahead(options.typeahead),
+    roving: normalizeRoving(options.roving),
+    activeDescendant: options.activeDescendant === true || options.activeDescendant !== void 0 && options.activeDescendant !== false && options.activeDescendant !== null,
+    descendantOwner: options.activeDescendant === void 0 || options.activeDescendant === false || options.activeDescendant === null ? null : options.activeDescendant === true ? () => resolveActiveDescendantOwner(container, listenTarget) : () => resolveElement(options.activeDescendant, container?.ownerDocument ?? null),
+    autoFocus: normalizeAutoFocus(options.autoFocus),
+    selectionOptions: normalizeSelection(options.selection),
+    observe: options.observe ?? false,
+    onlyWhenFocusedInside: options.onlyWhenFocusedInside !== false,
+    when: options.when ?? null,
+    ignoreEditable: options.ignoreEditable !== false,
+    editableSelector: options.editableSelector ?? null,
+    stopPropagation: options.stopPropagation !== false,
+    preventDefault: options.preventDefault !== false,
+    capture: options.capture === true,
+    pointerSync: options.pointerSync === true,
+    handlers: {
+      onFocus: options.onFocus,
+      onBlur: options.onBlur,
+      onSelect: options.onSelect,
+      onAction: options.onAction,
+      onEscape: options.onEscape,
+      onRefresh: options.onRefresh
+    }
+  };
+  return resolved;
+}
+function strategyForMode(mode) {
+  switch (mode) {
+    case "horizontal":
+      return createSequentialStrategy("horizontal");
+    case "grid":
+      return createGridStrategy();
+    case "directional":
+      return createDirectionalStrategy();
+    case "custom":
+      return () => null;
+    case "sequential":
+    case "vertical":
+    default:
+      return createSequentialStrategy("vertical");
+  }
+}
+function normalizeTypeahead(input) {
+  if (!input) return null;
+  if (input === true) return { enabled: true };
+  return input.enabled === false ? null : { ...input, enabled: true };
+}
+function resolveActiveDescendantOwner(container, listenTarget) {
+  if (listenTarget && typeof listenTarget.nodeType === "number") {
+    const element = listenTarget;
+    if (!container || contains(container, element) || element === container) return element;
+  }
+  if (typeof document === "undefined") return null;
+  const active = document.activeElement;
+  if (active && container && contains(container, active)) return active;
+  return null;
+}
+function normalizeRoving(input) {
+  if (input === false) return { enabled: false };
+  if (input === true || input === void 0) return { enabled: true };
+  return input;
+}
+function normalizeAutoFocus(input) {
+  if (!input) return { enabled: false };
+  if (input === true) return { enabled: true };
+  return input;
+}
+function normalizeSelection(input) {
+  if (!input) return null;
+  if (input === true) return { enabled: true, mode: "single" };
+  return input.enabled === false ? null : { enabled: true, ...input };
+}
+var NavigationController = class {
+  constructor(options = {}, overrides = {}) {
+    this.events = new EventManager();
+    this.emitter = new Emitter();
+    this.keydownDisposer = null;
+    this.auxDisposers = [];
+    this.syncPending = true;
+    this.destroyed = false;
+    this.resolved = resolveOptions(options, overrides);
+    this.collection = new ItemCollection(
+      this.resolved.container,
+      {
+        selector: this.resolved.selector,
+        disabledSelector: this.resolved.disabledSelector,
+        skipHidden: this.resolved.skipHidden,
+        filter: this.resolved.filter,
+        observe: this.resolved.observe
+      },
+      () => {
+        this.syncPending = true;
+      }
+    );
+    this.focus = new FocusManager({
+      roving: this.resolved.roving,
+      virtual: this.resolved.activeDescendant,
+      descendantOwner: this.resolved.descendantOwner,
+      disabledSelector: this.resolved.disabledSelector,
+      skipHidden: this.resolved.skipHidden,
+      onFocus: (element, index, action) => {
+        const selection = this.resolved.selectionOptions;
+        if (selection?.followFocus && selection.mode !== "multiple") {
+          this.selectionManager?.select(index);
+        }
+        this.resolved.handlers.onFocus?.(element, index);
+        this.emitter.emit("focus", { element, index, action });
+      },
+      onBlur: (element, index) => {
+        this.resolved.handlers.onBlur?.(element, index);
+        this.emitter.emit("blur", { element, index });
+      }
+    });
+    if (options.elements) this.collection.setItems(options.elements);
+    this.matcher = new KeyMatcher(this.resolved.keys, this.resolved.sequences ?? []);
+    this.typeaheadController = this.resolved.typeahead ? createTypeahead(this.resolved.typeahead) : null;
+    this.selectionManager = this.resolved.selectionOptions ? new SelectionManager(this.resolved.selectionOptions) : null;
+    this.selectionManager?.setDiffHandler((selected, added, removed) => {
+      this.emitter.emit("selectionchange", { selected, added, removed });
+    });
+    this.selectionManager?.bindItems(() => this.collection.items);
+    if (options.enabled !== false) this.attach();
+    if (this.resolved.autoFocus.enabled) this.applyAutoFocus();
+  }
+  get container() {
+    return this.resolved.container;
+  }
+  get items() {
+    this.sync();
+    return this.collection.items;
+  }
+  get activeElement() {
+    this.sync();
+    return this.focus.element;
+  }
+  get activeIndex() {
+    this.sync();
+    return this.focus.focusedIndex;
+  }
+  get currentIndex() {
+    this.sync();
+    return this.focus.index;
+  }
+  get mode() {
+    return this.resolved.mode;
+  }
+  get loop() {
+    return this.resolved.loop;
+  }
+  get enabled() {
+    return this.keydownDisposer !== null;
+  }
+  get selection() {
+    this.sync();
+    return this.selectionManager;
+  }
+  next(count = 1) {
+    return this.step(count, "next");
+  }
+  previous(count = 1) {
+    return this.step(-count, "previous");
+  }
+  up() {
+    return this.move("up");
+  }
+  down() {
+    return this.move("down");
+  }
+  left() {
+    return this.move("left");
+  }
+  right() {
+    return this.move("right");
+  }
+  move(direction) {
+    this.collection.revalidate();
+    this.sync();
+    const index = this.resolveNavigation(direction, direction, null);
+    if (index === null) return null;
+    const focused = this.focus.focusIndex(index, direction);
+    if (focused) this.afterMove(index, direction, null);
+    return focused;
+  }
+  first() {
+    this.collection.revalidate();
+    this.sync();
+    if (this.collection.items.length === 0) return null;
+    const focused = this.focus.focusIndex(0, "first");
+    if (focused) this.afterMove(0, "first", null);
+    return focused;
+  }
+  last() {
+    this.collection.revalidate();
+    this.sync();
+    const total = this.collection.items.length;
+    if (total === 0) return null;
+    const focused = this.focus.focusIndex(total - 1, "last");
+    if (focused) this.afterMove(total - 1, "last", null);
+    return focused;
+  }
+  focusFirst() {
+    return this.first();
+  }
+  focusLast() {
+    return this.last();
+  }
+  pageUp() {
+    return this.step(-this.resolved.pageSize, "pageUp");
+  }
+  pageDown() {
+    return this.step(this.resolved.pageSize, "pageDown");
+  }
+  focusIndex(index) {
+    this.collection.revalidate();
+    this.sync();
+    return this.focus.focusIndex(index, null);
+  }
+  setActiveIndex(index, options = {}) {
+    this.collection.revalidate();
+    this.sync();
+    if (options.focus === false) {
+      this.focus.setActiveIndex(index);
+      return this.collection.items[index] ?? null;
+    }
+    return this.focus.focusIndex(index, null);
+  }
+  focusElement(element) {
+    this.sync();
+    return this.focus.focusElement(element ?? null);
+  }
+  restoreFocus() {
+    return this.focus.restore();
+  }
+  rememberFocus() {
+    if (typeof document === "undefined") return;
+    const active = document.activeElement;
+    if (!active || active === document.body || active === document.documentElement) return;
+    if (this.resolved.container && contains(this.resolved.container, active)) return;
+    this.focus.remember(active);
+  }
+  select(elementOrIndex) {
+    this.sync();
+    const index = this.resolveIndex(elementOrIndex);
+    const element = index >= 0 ? this.collection.items[index] : void 0;
+    if (!element) return;
+    this.applySelection(index, false);
+    this.resolved.handlers.onSelect?.(element, index);
+    this.emitter.emit("select", { element, index });
+    this.emitAction("select", null, element, index);
+  }
+  perform(action, event = null) {
+    if (this.destroyed) return false;
+    return this.runAction(action, event, null);
+  }
+  setContainer(container) {
+    const next = resolveElement(container, this.resolved.container?.ownerDocument ?? null);
+    if (next === this.resolved.container) return;
+    const attached = this.keydownDisposer !== null;
+    if (attached) this.detach();
+    this.resolved.container = next;
+    if (!this.resolved.pinnedTarget) {
+      this.resolved.listenTarget = next ?? (typeof document !== "undefined" ? document : null);
+    }
+    this.collection.setContainer(next);
+    if (attached) this.attach();
+    this.syncPending = true;
+    this.emitter.emit("refresh", { items: this.collection.items });
+  }
+  refresh() {
+    const items = this.collection.refresh();
+    this.sync(true);
+    this.resolved.handlers.onRefresh?.(items);
+    this.emitter.emit("refresh", { items });
+    return items;
+  }
+  add(element) {
+    this.collection.add(element);
+  }
+  remove(element) {
+    this.collection.remove(element);
+  }
+  setItems(elements) {
+    this.collection.setItems(elements);
+  }
+  enable() {
+    if (this.destroyed || this.enabled) return;
+    this.attach();
+  }
+  disable() {
+    this.detach();
+    this.matcher.resetSequence();
+    this.typeaheadController?.reset();
+  }
+  update(options) {
+    if (this.destroyed) return;
+    if (options.container !== void 0) this.setContainer(options.container);
+    if (options.mode !== void 0 && options.mode !== this.resolved.mode) {
+      this.resolved.mode = options.mode;
+      if (!this.resolved.userStrategy) {
+        this.resolved.strategy = strategyForMode(options.mode);
+      }
+    }
+    if (options.loop !== void 0) this.resolved.loop = options.loop === true;
+    if (options.columns !== void 0) this.resolved.columns = options.columns ?? 0;
+    if (options.pageSize !== void 0) this.resolved.pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+    if (options.keys !== void 0) this.resolved.userKeys = options.keys;
+    if (options.keys !== void 0 || options.mode !== void 0) {
+      this.resolved.keys = mergeKeys(
+        this.resolved.defaultKeys ?? defaultKeysFor(this.resolved.mode),
+        this.resolved.userKeys,
+        this.resolved.useDefaultKeys
+      );
+      this.matcher.loadMap(this.resolved.keys);
+    }
+    if (options.enabled === true) this.enable();
+    else if (options.enabled === false) this.disable();
+    this.syncPending = true;
+  }
+  on(event, handler) {
+    return this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.detach();
+    this.events.dispose();
+    this.collection.dispose();
+    this.matcher.dispose();
+    this.typeaheadController?.dispose();
+    this.typeaheadController = null;
+    this.selectionManager?.dispose();
+    this.selectionManager = null;
+    this.focus.dispose();
+    this.emitter.emit("destroy", {});
+    this.emitter.clear();
+  }
+  attach() {
+    const target = this.resolved.listenTarget;
+    if (!target || this.keydownDisposer) return;
+    const listenerOptions = { capture: this.resolved.capture, passive: false };
+    this.keydownDisposer = this.events.add(target, "keydown", (event) => this.onKeydown(event), listenerOptions);
+    this.auxDisposers.push(
+      this.events.add(target, "focusin", (event) => {
+        this.focus.observe(event.target, this.resolved.container);
+      })
+    );
+    if (this.resolved.pointerSync && this.resolved.container) {
+      this.auxDisposers.push(
+        this.events.add(this.resolved.container, "click", (event) => this.onPointer(event)),
+        this.events.add(this.resolved.container, "pointerover", (event) => this.onPointerOver(event))
+      );
+    }
+    if (this.resolved.observe) this.collection.startObserving();
+  }
+  detach() {
+    if (this.keydownDisposer) {
+      this.keydownDisposer();
+      this.keydownDisposer = null;
+    }
+    for (const dispose of this.auxDisposers) dispose();
+    this.auxDisposers.length = 0;
+    this.collection.stopObserving();
+  }
+  applyAutoFocus() {
+    const { target } = this.resolved.autoFocus;
+    this.sync(true);
+    const items = this.collection.items;
+    if (items.length === 0) return;
+    let index = 0;
+    if (target === "last") index = items.length - 1;
+    else if (typeof target === "function") index = target(items);
+    this.focus.focusIndex(clampIndex(index, items.length, false), null);
+  }
+  onKeydown(event) {
+    if (this.destroyed) return;
+    if (this.resolved.when && !this.resolved.when()) return;
+    this.collection.revalidate();
+    const normalized = normalizeKeyEvent(event);
+    const match = this.matcher.match(normalized, this);
+    if (this.reservedTarget(event) && !(match?.complete ?? false)) return;
+    if (!match) {
+      if (this.handleTypeahead(normalized, event)) return;
+      if (!isModifierKey(normalized.key)) this.emitter.emit("keydown", { event, handled: false });
+      return;
+    }
+    if (!match.complete) {
+      if (match.preventDefault && this.resolved.preventDefault) event.preventDefault();
+      return;
+    }
+    if (this.reservedTarget(event)) return;
+    if (this.resolved.onlyWhenFocusedInside && !this.focusIsInside()) return;
+    const actions = match.actions;
+    for (let i = 0; i < actions.length; i++) {
+      if (this.runAction(actions[i], event, match)) {
+        if (this.resolved.preventDefault) event.preventDefault();
+        if (this.resolved.stopPropagation) event.stopPropagation();
+        this.emitter.emit("keydown", { event, handled: true });
+        return;
+      }
+    }
+    this.emitter.emit("keydown", { event, handled: false });
+  }
+  reservedTarget(event) {
+    if (!this.resolved.ignoreEditable) return false;
+    if (event.target === this.resolved.listenTarget) return false;
+    return isEditableTarget(event.target, this.resolved.editableSelector);
+  }
+  focusIsInside() {
+    if (typeof document === "undefined") return true;
+    const active = document.activeElement;
+    const container = this.resolved.container;
+    const nothingFocused = !active || active === document.body || active === document.documentElement;
+    if (nothingFocused) {
+      return this.focus.element !== null || container === null;
+    }
+    if (!container) return true;
+    if (contains(container, active)) return true;
+    return this.focus.element !== null && contains(container, this.focus.element);
+  }
+  handleTypeahead(normalized, event) {
+    const typeahead = this.typeaheadController;
+    if (!typeahead) return false;
+    if (!normalized.isPrintable || normalized.key.length !== 1 || normalized.repeat) return false;
+    this.sync();
+    const items = this.collection.items;
+    if (items.length === 0) return false;
+    const match = typeahead.handle(normalized.key, items, this.focus.index);
+    if (!match) return false;
+    const index = items.indexOf(match);
+    if (index === -1) return false;
+    const focused = this.focus.focusIndex(index, "typeahead");
+    if (!focused) return false;
+    this.afterMove(index, "typeahead", event);
+    if (this.resolved.preventDefault) event.preventDefault();
+    if (this.resolved.stopPropagation) event.stopPropagation();
+    this.emitter.emit("keydown", { event, handled: true });
+    return true;
+  }
+  runAction(action, event, match) {
+    const fromSequence = match?.fromSequence === true;
+    this.sync();
+    const items = this.collection.items;
+    const index = this.focus.index;
+    const element = index >= 0 ? items[index] ?? null : null;
+    if (MOVEMENT_ACTIONS.has(action)) {
+      if (items.length === 0) return false;
+      return this.runMovement(action, event, items, fromSequence);
+    }
+    switch (action) {
+      case "select": {
+        if (index < 0) return false;
+        const item = items[index];
+        if (this.resolved.selectionOptions?.selectOnActivate !== false) this.applySelection(index, false);
+        this.resolved.handlers.onSelect?.(item, index);
+        this.emitter.emit("select", { element: item, index });
+        this.emitAction(action, event, item, index, fromSequence);
+        return this.selectionManager !== null || this.isHeard(action) || !activatesNatively(item);
+      }
+      case "toggle": {
+        const mode = this.selectionManager?.mode;
+        if (!this.selectionManager || mode === "single" || mode === "none") return false;
+        if (index < 0) return false;
+        this.selectionManager.toggle(index);
+        this.emitAction(action, event, items[index], index, fromSequence);
+        return true;
+      }
+      case "selectAll": {
+        if (!this.selectionManager) return false;
+        this.selectionManager.selectAll();
+        this.emitAction(action, event, element, index, fromSequence);
+        return true;
+      }
+      case "escape": {
+        this.typeaheadController?.reset();
+        this.matcher.resetSequence();
+        this.emitAction(action, event, element, index, fromSequence);
+        this.resolved.handlers.onEscape?.(event);
+        return this.isHeard(action);
+      }
+      default: {
+        this.emitAction(action, event, element, index, fromSequence);
+        return true;
+      }
+    }
+  }
+  runMovement(action, event, items, fromSequence = false) {
+    const direction = action === "up" || action === "down" || action === "left" || action === "right" ? action : null;
+    let target;
+    switch (action) {
+      case "first":
+        target = this.resolveNavigation(action, null, event) ?? 0;
+        break;
+      case "last":
+        target = this.resolveNavigation(action, null, event) ?? items.length - 1;
+        break;
+      case "pageUp":
+      case "pageDown": {
+        const delta = (action === "pageDown" ? 1 : -1) * this.resolved.pageSize;
+        const current = this.focus.index;
+        const raw = current < 0 ? delta > 0 ? 0 : items.length - 1 : current + delta;
+        target = clampIndex(raw, items.length, this.resolved.loop);
+        break;
+      }
+      default: {
+        const resolved = this.resolveNavigation(action, direction, event);
+        if (resolved === null) return false;
+        target = resolved;
+      }
+    }
+    const focused = this.focus.focusIndex(target, action);
+    if (!focused) return false;
+    this.afterMove(target, action, event, fromSequence);
+    return true;
+  }
+  isHeard(action) {
+    const { onSelect, onEscape, onAction } = this.resolved.handlers;
+    if (onAction || this.ownsAction(action)) return true;
+    return action === "escape" ? onEscape !== void 0 : onSelect !== void 0;
+  }
+  ownsAction(_action) {
+    return false;
+  }
+  emitAction(action, event, element, index, fromSequence = false) {
+    this.resolved.handlers.onAction?.(action, event, element, index);
+    this.emitter.emit("action", { action, event, element, index, fromSequence });
+  }
+  afterMove(index, action, event, fromSequence = false) {
+    this.emitAction(action, event, this.collection.items[index] ?? null, index, fromSequence);
+    const selection = this.resolved.selectionOptions;
+    if (!selection) return;
+    if (!selection.followFocus && selection.mode === "range" && selection.shiftExtendsRange !== false && event?.shiftKey) {
+      this.extendRangeTo(index);
+    }
+  }
+  resolveNavigation(action, direction, event) {
+    const items = this.collection.items;
+    if (items.length === 0) return null;
+    const context = this.createContext(action, direction, event);
+    if (this.resolved.onBeforeNavigate) {
+      const override = this.resolved.onBeforeNavigate(context);
+      if (typeof override === "number" && override >= 0 && override < items.length) return override;
+    }
+    const result = this.resolved.strategy(context);
+    if (typeof result !== "number" || result < 0) return null;
+    return result >= items.length ? items.length - 1 : result;
+  }
+  createContext(action, direction, event) {
+    return {
+      items: this.collection.items,
+      container: this.resolved.container,
+      index: this.focus.index,
+      direction,
+      action,
+      event,
+      shiftKey: event?.shiftKey === true,
+      altKey: event?.altKey === true,
+      ctrlKey: event?.ctrlKey === true,
+      metaKey: event?.metaKey === true,
+      columns: this.resolved.columns,
+      loop: this.resolved.loop,
+      version: this.collection.version,
+      rectOf: createRectOf(this.collection)
+    };
+  }
+  step(delta, action) {
+    this.collection.revalidate();
+    this.focus.sync(this.collection.items, this.resolved.container);
+    this.sync();
+    const total = this.collection.items.length;
+    if (total === 0 || delta === 0) return null;
+    const current = this.focus.index;
+    const raw = current < 0 ? delta > 0 ? 0 : total - 1 : current + delta;
+    const target = clampIndex(raw, total, this.resolved.loop);
+    const focused = this.focus.focusIndex(target, action);
+    if (focused && action) this.afterMove(target, action, null);
+    return focused;
+  }
+  resolveIndex(elementOrIndex) {
+    if (elementOrIndex === void 0) return this.focus.index;
+    if (typeof elementOrIndex === "number") return elementOrIndex;
+    return this.collection.indexOf(elementOrIndex);
+  }
+  applySelection(index, extend = false) {
+    const manager = this.selectionManager;
+    if (!manager) return;
+    manager.select(index, extend);
+  }
+  extendRangeTo(index) {
+    const manager = this.selectionManager;
+    if (!manager) return;
+    const items = this.collection.items;
+    const anchor = manager.anchor;
+    const from = anchor ? items.indexOf(anchor) : index;
+    if (from < 0) return;
+    manager.selectRange(from, index);
+  }
+  onPointer(event) {
+    const item = this.itemFromEvent(event);
+    if (!item) return;
+    const index = this.collection.indexOf(item);
+    if (index === -1) return;
+    this.focus.focusIndex(index, "select");
+    const manager = this.selectionManager;
+    if (!manager) return;
+    const mode = manager.mode;
+    if (mode === "none") return;
+    if (mode === "multiple") {
+      if (event.ctrlKey || event.metaKey) manager.toggle(index);
+      else manager.select(index);
+      return;
+    }
+    if (mode === "range" && event.shiftKey) {
+      this.extendRangeTo(index);
+      return;
+    }
+    this.applySelection(index, false);
+  }
+  onPointerOver(event) {
+    const item = this.itemFromEvent(event);
+    if (item) this.focus.observe(item, this.resolved.container);
+  }
+  itemFromEvent(event) {
+    const target = event.target;
+    if (!target) return null;
+    this.collection.revalidate();
+    this.sync();
+    const items = this.collection.items;
+    const selector = this.resolved.selector;
+    if (typeof selector === "string" && typeof target.closest === "function") {
+      try {
+        const closest = target.closest(selector);
+        if (closest && items.indexOf(closest) !== -1) return closest;
+      } catch {
+      }
+    }
+    let node = target;
+    while (node) {
+      if (items.indexOf(node) !== -1) return node;
+      node = node.parentElement;
+    }
+    return null;
+  }
+  sync(force = false) {
+    if (this.destroyed) return;
+    if (!force && !this.syncPending) return;
+    this.syncPending = false;
+    const items = this.collection.items;
+    this.focus.sync(items, this.resolved.container);
+    this.selectionManager?.sync(items);
+  }
+};
+function activatesNatively(element) {
+  return element.matches("a[href],button,summary,input,select,textarea");
+}
+function clampIndex(index, total, loop) {
+  if (total === 0) return -1;
+  if (loop) return (index % total + total) % total;
+  if (index < 0) return 0;
+  if (index >= total) return total - 1;
+  return index;
+}
+function createKeystra(options = {}) {
+  return new NavigationController(options);
+}
+
+export { COMMAND_PALETTE_KEYS, EventManager, GRID_KEYS, HORIZONTAL_KEYS, ItemCollection, KeyMatcher, LIST_KEYS, MENU_KEYS, NavigationController, ROVING_KEYS, TABS_KEYS_HORIZONTAL, TABS_KEYS_VERTICAL, TREE_KEYS, VERTICAL_KEYS, codeToKey, createKeyMatcher, createKeystra, createRafThrottle, createRectOf, createTypeahead, defaultKeysFor, describeEvent, formatKeyCombo, isModifierKey, isPrintableKey, keyEquals, mergeKeys, normalizeKeyEvent, normalizeKeyName, parseKeyBinding, resolveOptions };