keystra 0.0.0-stage → 0.1.1

package/dist/patterns.cjs

@@ -0,0 +1,3505 @@
+'use strict';
+
+// src/utils/dom.ts
+function hasDom() {
+  return typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined";
+}
+function resolveElement(target, root = null) {
+  if (target == null) return null;
+  if (typeof target === "function") {
+    return resolveElement(target(), root);
+  }
+  if (typeof target === "string") {
+    const scope = root ?? (hasDom() ? document : null);
+    if (!scope) return null;
+    try {
+      return scope.querySelector(target);
+    } catch {
+      return null;
+    }
+  }
+  return target;
+}
+function queryItems(container, selector) {
+  if (!container) return [];
+  if (typeof selector === "function") {
+    const result = selector(container);
+    return Array.from(result);
+  }
+  if (!selector) return [];
+  try {
+    return Array.from(container.querySelectorAll(selector));
+  } catch {
+    return [];
+  }
+}
+var DISABLED_SELECTOR_DEFAULT = "[disabled],[aria-disabled='true']";
+function isDisabled(element, selector = DISABLED_SELECTOR_DEFAULT) {
+  if (!selector) return false;
+  const html = element;
+  if (html.disabled === true) return true;
+  if (element.getAttribute("aria-disabled") === "true") return true;
+  if (selector === DISABLED_SELECTOR_DEFAULT) return element.hasAttribute("disabled");
+  try {
+    return element.matches(selector);
+  } catch {
+    return false;
+  }
+}
+function isHidden(element) {
+  const html = element;
+  const probe = html;
+  if (typeof probe.checkVisibility === "function") {
+    try {
+      return !probe.checkVisibility.call(html, { checkOpacity: false, checkVisibilityCSS: true });
+    } catch {
+    }
+  }
+  let node = html;
+  while (node && node.nodeType === 1) {
+    if (node.hidden === true) return true;
+    if (node.style && node.style.display === "none") return true;
+    node = node.parentElement;
+  }
+  return false;
+}
+var EDITABLE_SELECTOR_DEFAULT = "input:not([type='hidden']):not([readonly]),textarea:not([readonly]),select,[contenteditable=''],[contenteditable='true'],[iscontenteditable]";
+function isEditableTarget(target, extraSelector) {
+  if (!target || typeof target.matches !== "function") return false;
+  const element = target;
+  const selector = extraSelector ? `${EDITABLE_SELECTOR_DEFAULT},${extraSelector}` : EDITABLE_SELECTOR_DEFAULT;
+  try {
+    if (element.matches(selector)) return true;
+  } catch {
+  }
+  const html = element;
+  return html.isContentEditable === true;
+}
+function getText(element) {
+  const label = element.getAttribute("aria-label") ?? element.textContent ?? "";
+  return label.replace(/\s+/g, " ").trim();
+}
+function setAttribute(element, name, value) {
+  if (value === null) element.removeAttribute(name);
+  else if (element.getAttribute(name) !== value) element.setAttribute(name, value);
+}
+function toggleClass(element, name, on) {
+  if (!name) return;
+  const html = element;
+  if (typeof html.classList?.toggle === "function") html.classList.toggle(name, on);
+}
+function focusElement(element, preventScroll = true) {
+  if (typeof element.focus !== "function") return false;
+  try {
+    element.focus({ preventScroll });
+  } catch {
+    try {
+      element.focus();
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function contains(parent, child) {
+  if (!parent || !child) return false;
+  if (parent === child) return true;
+  if (typeof parent.contains === "function") return parent.contains(child);
+  let node = child;
+  while (node) {
+    if (node === parent) return true;
+    node = node.parentNode;
+  }
+  return false;
+}
+function resolveEventTarget(target) {
+  if (target == null) return null;
+  if (typeof target === "string") return resolveElement(target);
+  if (typeof target === "function") return resolveEventTarget(target());
+  return target;
+}
+var idCounter = 0;
+function ensureId(element, prefix) {
+  const existing = element.id;
+  if (existing) return existing;
+  idCounter += 1;
+  const generated = `${prefix}-${idCounter}`;
+  element.id = generated;
+  return generated;
+}
+
+// src/focus/roving-focus.ts
+var RovingTabindex = class {
+  constructor(options = {}) {
+    this.current = /* @__PURE__ */ new WeakMap();
+    this.originals = /* @__PURE__ */ new Map();
+    this.active = null;
+    this.respectNegative = options.respectNegative !== false;
+    this.disabled = options.disabled === true;
+  }
+  get activeElement() {
+    return this.active;
+  }
+  sync(element, others) {
+    if (this.disabled) return;
+    const desired = element ? this.desiredFor(element) : null;
+    for (let i = 0; i < others.length; i++) {
+      const item = others[i];
+      if (item === element) continue;
+      this.write(item, "-1");
+    }
+    this.active = element;
+    if (element && desired !== null) this.write(element, desired);
+    this.forgetDetached(others.length);
+  }
+  move(element) {
+    if (this.disabled) return;
+    const desired = this.desiredFor(element);
+    if (this.active && this.active !== element) this.write(this.active, "-1");
+    this.active = element;
+    this.write(element, desired);
+  }
+  forgetDetached(live) {
+    if (this.originals.size <= live) return;
+    for (const element of this.originals.keys()) {
+      if (!element.isConnected) this.originals.delete(element);
+    }
+  }
+  authoredTabStop(items) {
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      const authored = this.originals.has(item) ? this.originals.get(item) : item.getAttribute("tabindex");
+      if (authored === "0") return item;
+    }
+    return null;
+  }
+  apply(element) {
+    if (this.disabled) return;
+    this.active = element;
+    if (element) this.write(element, this.desiredFor(element));
+  }
+  desiredFor(element) {
+    if (this.respectNegative) {
+      const authored = this.originals.has(element) ? this.originals.get(element) : element.getAttribute("tabindex");
+      if (authored === "-1") return "-1";
+    }
+    return "0";
+  }
+  write(element, value) {
+    if (this.current.get(element) === value) return;
+    if (!this.originals.has(element)) this.originals.set(element, element.getAttribute("tabindex"));
+    element.setAttribute("tabindex", value);
+    this.current.set(element, value);
+  }
+  restore() {
+    for (const [element, value] of this.originals) {
+      if (value === null) element.removeAttribute("tabindex");
+      else element.setAttribute("tabindex", value);
+      this.current.delete(element);
+    }
+    this.originals.clear();
+    this.active = null;
+  }
+  get touched() {
+    return this.originals.size;
+  }
+};
+
+// src/focus/focus-manager.ts
+var FocusManager = class {
+  constructor(options = {}) {
+    this.items = [];
+    this.activeElement = null;
+    this.activeIndex = -1;
+    this.outsideElement = null;
+    this.lastInsideElement = null;
+    this.lastKnownIndex = 0;
+    this.cleared = false;
+    this.started = false;
+    this.container = null;
+    this.markedOption = null;
+    this.options = options;
+    this.virtual = options.virtual === true;
+    const roving = options.roving;
+    this.rovingEnabled = roving !== false && (typeof roving !== "object" || roving.enabled !== false);
+    this.roving = new RovingTabindex({
+      disabled: !this.rovingEnabled,
+      respectNegative: typeof roving === "object" ? roving.force !== true : true
+    });
+  }
+  get element() {
+    return this.activeElement;
+  }
+  get index() {
+    return this.activeIndex;
+  }
+  get focusedIndex() {
+    if (this.activeIndex < 0) return -1;
+    if (this.virtual) return this.activeIndex;
+    if (typeof document === "undefined") return this.activeIndex;
+    const active = document.activeElement;
+    const current = this.activeElement;
+    if (!current) return -1;
+    if (active === current) return this.activeIndex;
+    if (active && contains(current, active)) return this.activeIndex;
+    return -1;
+  }
+  get previousElement() {
+    return this.outsideElement;
+  }
+  get lastFocused() {
+    return this.lastInsideElement;
+  }
+  sync(items, container) {
+    const previous = this.activeElement;
+    if (this.activeIndex >= 0) this.lastKnownIndex = this.activeIndex;
+    this.items = items;
+    if (container !== void 0) this.container = container;
+    if (previous) {
+      const index = items.indexOf(previous);
+      if (index !== -1 && this.isUsable(previous)) {
+        this.activeIndex = index;
+        this.promote(previous, items);
+        return index;
+      }
+    }
+    const fromDocument = previous || !this.cleared ? this.readActiveFromDocument(container) : -1;
+    if (fromDocument >= 0) {
+      const element = items[fromDocument];
+      this.activeElement = element;
+      this.activeIndex = fromDocument;
+      this.lastInsideElement = element;
+      this.lastKnownIndex = fromDocument;
+      this.promote(element, items);
+      return fromDocument;
+    }
+    this.activeElement = null;
+    this.activeIndex = -1;
+    let candidate = null;
+    if (previous && items.length > 0) {
+      const previousIndex = this.lastKnownIndex;
+      candidate = items[Math.min(previousIndex, items.length - 1)] ?? items[0] ?? null;
+    } else if (!this.started && items.length > 0) {
+      candidate = this.roving.authoredTabStop(items) ?? items[0] ?? null;
+      const index = candidate ? items.indexOf(candidate) : -1;
+      if (index > 0 && candidate && this.isUsable(candidate)) {
+        this.activeElement = candidate;
+        this.activeIndex = index;
+        this.lastInsideElement = candidate;
+        this.lastKnownIndex = index;
+      }
+    } else {
+      candidate = items[0] ?? null;
+    }
+    this.started = true;
+    this.promote(candidate, items);
+    return this.activeIndex;
+  }
+  promote(element, items) {
+    this.roving.sync(this.virtual ? null : element, items);
+    this.writeActiveDescendant(this.virtual ? element : null);
+  }
+  writeActiveDescendant(element) {
+    if (!this.virtual) return;
+    this.markOption(element);
+    const owner = this.options.descendantOwner?.() ?? null;
+    if (!owner) return;
+    if (!element) {
+      if (owner.hasAttribute("aria-activedescendant")) owner.removeAttribute("aria-activedescendant");
+      return;
+    }
+    const id = ensureId(element, "keystra-item");
+    if (owner.getAttribute("aria-activedescendant") !== id) {
+      owner.setAttribute("aria-activedescendant", id);
+    }
+  }
+  markOption(element) {
+    if (this.markedOption === element) return;
+    if (this.markedOption) this.markedOption.setAttribute("aria-selected", "false");
+    this.markedOption = element?.getAttribute("role") === "option" ? element : null;
+    if (this.markedOption) this.markedOption.setAttribute("aria-selected", "true");
+  }
+  observe(element, container) {
+    if (!element) return;
+    if (container && !contains(container, element)) return;
+    const index = this.items.indexOf(element);
+    if (index === -1) return;
+    const item = this.items[index];
+    this.activeElement = item;
+    this.activeIndex = index;
+    this.lastInsideElement = item;
+    this.lastKnownIndex = index;
+    if (!this.virtual) this.roving.apply(item);
+    this.writeActiveDescendant(item);
+  }
+  focusIndex(index, action = null, preventScroll, moveFocus = true) {
+    const items = this.items;
+    if (index < 0 || index >= items.length) return null;
+    const element = items[index];
+    if (!this.isUsable(element)) return null;
+    const previous = this.activeElement;
+    if (previous && previous !== element) {
+      const previousIndex = items.indexOf(previous);
+      if (previousIndex !== -1) this.options.onBlur?.(previous, previousIndex);
+    }
+    this.captureOutside(previous);
+    this.activeElement = element;
+    this.activeIndex = index;
+    this.cleared = false;
+    this.lastInsideElement = element;
+    this.lastKnownIndex = index;
+    if (this.virtual) this.writeActiveDescendant(element);
+    else this.roving.move(element);
+    if (moveFocus && !this.virtual) {
+      focusElement(element, preventScroll ?? this.options.preventScroll !== false);
+    }
+    this.options.onFocus?.(element, index, action);
+    return element;
+  }
+  setActiveIndex(index) {
+    const element = index >= 0 ? this.items[index] ?? null : null;
+    this.activeElement = element;
+    this.activeIndex = element ? index : -1;
+    if (element) {
+      this.cleared = false;
+      this.lastInsideElement = element;
+      this.lastKnownIndex = index;
+    } else {
+      this.cleared = index < 0;
+    }
+    this.promote(element ?? this.items[0] ?? null, this.items);
+  }
+  focusElement(element, action = null) {
+    if (!element) return false;
+    const index = this.items.indexOf(element);
+    if (index === -1) return false;
+    return this.focusIndex(index, action) !== null;
+  }
+  restore() {
+    const target = this.outsideElement;
+    if (target && typeof target.focus === "function" && !isHidden(target) && !isDisabled(target)) {
+      focusElement(target, this.options.preventScroll !== false);
+      return true;
+    }
+    if (this.virtual) return false;
+    if (this.lastInsideElement && this.items.indexOf(this.lastInsideElement) !== -1) {
+      return this.focusElement(this.lastInsideElement);
+    }
+    return this.focusIndex(this.activeIndex) !== null;
+  }
+  remember(element) {
+    if (element) this.outsideElement = element;
+  }
+  clear() {
+    this.activeElement = null;
+    this.activeIndex = -1;
+    this.items = [];
+    this.lastInsideElement = null;
+    this.lastKnownIndex = 0;
+  }
+  dispose() {
+    this.writeActiveDescendant(null);
+    this.roving.restore();
+    this.clear();
+    this.outsideElement = null;
+  }
+  isUsable(element) {
+    if (!element) return false;
+    if (isDisabled(element, this.options.disabledSelector ?? null)) return false;
+    if (this.options.skipHidden !== false && isHidden(element)) return false;
+    return true;
+  }
+  captureOutside(current) {
+    if (typeof document === "undefined") return;
+    const active = document.activeElement;
+    if (!active || active === document.body || active === document.documentElement) return;
+    if (current && active === current) return;
+    if (this.items.indexOf(active) !== -1) return;
+    if (this.container && contains(this.container, active)) return;
+    this.outsideElement = active;
+  }
+  readActiveFromDocument(container) {
+    if (typeof document === "undefined") return -1;
+    const active = document.activeElement;
+    if (!active || active === document.body) return -1;
+    const index = this.items.indexOf(active);
+    if (index !== -1) return index;
+    if (container) {
+      for (let i = 0; i < this.items.length; i++) {
+        if (contains(this.items[i], active)) return i;
+      }
+    }
+    return -1;
+  }
+};
+
+// src/selection/selection-manager.ts
+var SelectionManager = class {
+  constructor(options = {}) {
+    this.selectedItems = [];
+    this.itemsValue = [];
+    this.provider = null;
+    this.anchorElement = null;
+    this.touched = /* @__PURE__ */ new Set();
+    this.onDiff = null;
+    this.needsInitial = true;
+    this.options = options;
+    this.modeValue = options.mode ?? "single";
+    this.attribute = options.attribute ?? null;
+    this.selectedClass = options.selectedClass;
+    this.aria = options.aria === true;
+  }
+  get mode() {
+    return this.modeValue;
+  }
+  get selected() {
+    return this.selectedItems;
+  }
+  get items() {
+    return this.provider ? this.provider() : this.itemsValue;
+  }
+  get selectedIndexes() {
+    const result = [];
+    for (let i = 0; i < this.selectedItems.length; i++) {
+      const index = this.items.indexOf(this.selectedItems[i]);
+      if (index !== -1) result.push(index);
+    }
+    return result.sort((a, b) => a - b);
+  }
+  get anchor() {
+    return this.anchorElement;
+  }
+  get size() {
+    return this.selectedItems.length;
+  }
+  bindItems(provider) {
+    this.provider = provider;
+  }
+  setDiffHandler(handler) {
+    this.onDiff = handler;
+  }
+  sync(items) {
+    if (this.itemsValue === items && !this.needsInitial) return;
+    this.itemsValue = items;
+    const current = this.items;
+    if (this.needsInitial) {
+      this.needsInitial = false;
+      this.applyInitial(this.options.initial);
+    }
+    if (this.aria || this.attribute || this.selectedClass) {
+      for (let i = 0; i < current.length; i++) {
+        const element = current[i];
+        this.paint(element, this.selectedItems.indexOf(element) !== -1);
+      }
+    }
+    if (this.touched.size > current.length) {
+      for (const element of this.touched) {
+        if (!element.isConnected && this.selectedItems.indexOf(element) === -1) this.touched.delete(element);
+      }
+    }
+    if (this.selectedItems.length === 0 && this.anchorElement === null) return;
+    let changed = false;
+    const kept = [];
+    for (const element of this.selectedItems) {
+      if (current.indexOf(element) !== -1) kept.push(element);
+      else {
+        this.paint(element, false);
+        changed = true;
+      }
+    }
+    if (this.anchorElement && current.indexOf(this.anchorElement) === -1) {
+      this.anchorElement = kept[0] ?? null;
+      changed = true;
+    }
+    if (changed) {
+      const previous = this.selectedItems;
+      this.selectedItems = kept;
+      this.options.onChange?.(this.selectedItems);
+      this.onDiff?.(this.selectedItems, [], previous.filter((element) => kept.indexOf(element) === -1));
+    }
+  }
+  applyInitial(initial) {
+    if (initial == null) return;
+    const current = this.items;
+    if (typeof initial === "number") {
+      const element = current[initial];
+      if (element) this.select(element);
+      return;
+    }
+    const list = Array.isArray(initial) ? initial : [initial];
+    for (const element of list) if (element) this.select(element, this.modeValue !== "single");
+  }
+  select(elementOrIndex, extend = false) {
+    if (this.modeValue === "none") return;
+    const element = this.resolve(elementOrIndex);
+    if (!element) return;
+    if (this.modeValue === "single" || !extend && this.modeValue !== "multiple") {
+      if (this.selectedItems.length === 1 && this.selectedItems[0] === element) {
+        this.anchorElement = element;
+        return;
+      }
+      const removed = this.selectedItems.slice();
+      this.selectedItems = [element];
+      this.anchorElement = element;
+      for (const item of removed) this.paint(item, false);
+      this.paint(element, true);
+      this.emit(removed);
+      return;
+    }
+    if (this.modeValue === "range" && extend && this.anchorElement) {
+      this.selectRange(this.anchorElement, element);
+      return;
+    }
+    if (this.selectedItems.indexOf(element) === -1) {
+      const previous = this.selectedItems.slice();
+      this.selectedItems.push(element);
+      this.paint(element, true);
+      this.emit(previous);
+    }
+    if (!this.anchorElement) this.anchorElement = element;
+  }
+  toggle(elementOrIndex) {
+    if (this.modeValue === "none") return;
+    const element = this.resolve(elementOrIndex);
+    if (!element) return;
+    if (this.modeValue === "single") {
+      if (this.selectedItems[0] === element) this.clear();
+      else this.select(element);
+      return;
+    }
+    const previous = this.selectedItems.slice();
+    const index = previous.indexOf(element);
+    if (index === -1) {
+      this.selectedItems.push(element);
+      this.paint(element, true);
+    } else {
+      this.selectedItems.splice(index, 1);
+      this.paint(element, false);
+      if (this.anchorElement === element) this.anchorElement = this.selectedItems[0] ?? null;
+    }
+    this.emit(previous);
+    if (!this.anchorElement && index === -1) this.anchorElement = element;
+  }
+  deselect(elementOrIndex) {
+    const element = this.resolve(elementOrIndex);
+    if (!element) return;
+    const index = this.selectedItems.indexOf(element);
+    if (index === -1) return;
+    const previous = this.selectedItems.slice();
+    this.selectedItems.splice(index, 1);
+    this.paint(element, false);
+    if (this.anchorElement === element) this.anchorElement = this.selectedItems[0] ?? null;
+    this.emit(previous);
+  }
+  selectRange(from, to) {
+    if (this.modeValue === "none") return;
+    const start = this.resolve(from);
+    const end = this.resolve(to);
+    if (!start || !end) return;
+    let a = this.items.indexOf(start);
+    let b = this.items.indexOf(end);
+    if (a === -1 || b === -1) return;
+    if (a > b) {
+      const swap = a;
+      a = b;
+      b = swap;
+    }
+    const previous = this.selectedItems.slice();
+    const next = [];
+    for (let i = a; i <= b; i++) {
+      const element = this.items[i];
+      if (element) next.push(element);
+    }
+    this.selectedItems = next;
+    this.anchorElement = start;
+    for (const element of previous) if (next.indexOf(element) === -1) this.paint(element, false);
+    for (const element of next) this.paint(element, true);
+    this.emit(previous);
+  }
+  selectAll() {
+    if (this.modeValue === "none" || this.modeValue === "single") {
+      if (this.modeValue === "single" && this.items[0]) this.select(this.items[0]);
+      return;
+    }
+    const previous = this.selectedItems.slice();
+    this.selectedItems = this.items.slice();
+    for (const element of this.selectedItems) this.paint(element, true);
+    this.anchorElement = this.items[0] ?? null;
+    this.emit(previous);
+  }
+  clear() {
+    if (this.selectedItems.length === 0 && !this.anchorElement) return;
+    const previous = this.selectedItems.slice();
+    this.selectedItems = [];
+    this.anchorElement = null;
+    for (const element of previous) this.paint(element, false);
+    this.emit(previous);
+  }
+  isSelected(elementOrIndex) {
+    const element = this.resolve(elementOrIndex);
+    return element !== null && this.selectedItems.indexOf(element) !== -1;
+  }
+  indexOfSelected(element) {
+    return this.selectedItems.indexOf(element);
+  }
+  setMode(mode) {
+    if (mode === this.modeValue) return;
+    this.modeValue = mode;
+    if (mode === "single" && this.selectedItems.length > 1) {
+      const previous = this.selectedItems.slice();
+      this.selectedItems = previous.slice(0, 1);
+      for (const element of previous) if (this.selectedItems.indexOf(element) === -1) this.paint(element, false);
+      this.emit(previous);
+    }
+    if (mode === "none") this.clear();
+  }
+  dispose() {
+    this.provider = null;
+    for (const element of this.touched) {
+      if (this.aria) setAttribute(element, "aria-selected", null);
+      if (this.attribute) element.removeAttribute(this.attribute);
+      toggleClass(element, this.selectedClass, false);
+    }
+    this.touched.clear();
+    this.selectedItems = [];
+    this.anchorElement = null;
+    this.itemsValue = [];
+  }
+  resolve(elementOrIndex) {
+    if (elementOrIndex === void 0 || elementOrIndex === null) return null;
+    if (typeof elementOrIndex === "number") return this.items[elementOrIndex] ?? null;
+    return elementOrIndex;
+  }
+  paint(element, on) {
+    this.touched.add(element);
+    if (this.aria) setAttribute(element, "aria-selected", on ? "true" : "false");
+    if (this.attribute) setAttribute(element, this.attribute, on ? "true" : null);
+    toggleClass(element, this.selectedClass, on);
+  }
+  emit(previous) {
+    const added = this.selectedItems.filter((element) => previous.indexOf(element) === -1);
+    const removed = previous.filter((element) => this.selectedItems.indexOf(element) === -1);
+    if (added.length === 0 && removed.length === 0) return;
+    this.options.onChange?.(this.selectedItems);
+    this.onDiff?.(this.selectedItems, added, removed);
+  }
+};
+
+// src/navigation/directional.ts
+function actionToDirection(action) {
+  switch (action) {
+    case "up":
+      return "up";
+    case "down":
+      return "down";
+    case "left":
+      return "left";
+    case "right":
+      return "right";
+    default:
+      return null;
+  }
+}
+function createDirectionalStrategy(options = {}) {
+  const crossWeight = options.crossAxisWeight ?? 2;
+  return (context) => {
+    const direction = context.direction ?? actionToDirection(context.action);
+    if (!direction) return null;
+    const items = context.items;
+    const total = items.length;
+    if (total === 0) return -1;
+    const from = context.index;
+    if (from < 0 || from >= total) {
+      return direction === "down" || direction === "right" ? 0 : total - 1;
+    }
+    const current = items[from];
+    if (!current) return null;
+    const origin = context.rectOf(current);
+    const ox = origin.left + origin.width / 2;
+    const oy = origin.top + origin.height / 2;
+    const horizontal = direction === "left" || direction === "right";
+    const sign = direction === "right" || direction === "down" ? 1 : -1;
+    let bestIndex = -1;
+    let bestScore = Infinity;
+    let nearestIndex = -1;
+    let nearestDistance = Infinity;
+    for (let i = 0; i < total; i++) {
+      if (i === from) continue;
+      const element = items[i];
+      const rect = context.rectOf(element);
+      if (rect.width === 0 && rect.height === 0) continue;
+      const dx = rect.left + rect.width / 2 - ox;
+      const dy = rect.top + rect.height / 2 - oy;
+      const distance = Math.hypot(dx, dy);
+      if (distance < nearestDistance) {
+        nearestDistance = distance;
+        nearestIndex = i;
+      }
+      const primary = (horizontal ? dx : dy) * sign;
+      if (primary <= 0) continue;
+      const cross = Math.abs(horizontal ? dy : dx);
+      if (cross > primary) continue;
+      const score = primary + cross * crossWeight;
+      if (score < bestScore) {
+        bestScore = score;
+        bestIndex = i;
+      }
+    }
+    if (bestIndex !== -1) return bestIndex;
+    const allowFallback = options.wrapFallback ?? context.loop;
+    return allowFallback ? nearestIndex : null;
+  };
+}
+
+// src/navigation/grid.ts
+function computeGridInfo(context) {
+  const items = context.items;
+  const total = items.length;
+  if (total === 0) return { starts: [0], columns: 1 };
+  const starts = [0];
+  let rowTop = context.rectOf(items[0]).top;
+  let currentColumns = 1;
+  let maxColumns = 1;
+  for (let i = 1; i < total; i++) {
+    const rect = context.rectOf(items[i]);
+    if (Math.abs(rect.top - rowTop) < 2) {
+      currentColumns++;
+      continue;
+    }
+    maxColumns = Math.max(maxColumns, currentColumns);
+    currentColumns = 1;
+    rowTop = rect.top;
+    starts.push(i);
+  }
+  return { starts, columns: Math.max(maxColumns, currentColumns) };
+}
+function declaredInfo(total, columns) {
+  const starts = [];
+  for (let start = 0; start < total; start += columns) starts.push(start);
+  if (starts.length === 0) starts.push(0);
+  return { starts, columns };
+}
+function rowOf(info, index) {
+  const starts = info.starts;
+  let row = 0;
+  for (let i = 0; i < starts.length; i++) {
+    if (starts[i] <= index) row = i;
+    else break;
+  }
+  return row;
+}
+function rowStart(info, row) {
+  return info.starts[row] ?? 0;
+}
+function rowEnd(info, row, total) {
+  return row + 1 < info.starts.length ? info.starts[row + 1] - 1 : total - 1;
+}
+function createGridStrategy(options = {}) {
+  const maintainColumn = options.maintainColumn !== false;
+  const rowHomeEnd = options.rowHomeEnd === true;
+  const declared = options.columns && options.columns > 0 ? options.columns : 0;
+  let cachedVersion = -1;
+  let cachedItems = null;
+  let cached = { starts: [0], columns: 1 };
+  return (context) => {
+    const items = context.items;
+    const total = items.length;
+    if (total === 0) return -1;
+    const columns = declared || context.columns;
+    const index = context.index;
+    const direction = context.direction ?? directionFromAction(context.action);
+    if (!direction) {
+      if (context.action === "first") {
+        if (!rowHomeEnd || index < 0) return 0;
+        const info2 = infoFor(context, columns, total);
+        return rowStart(info2, rowOf(info2, index));
+      }
+      if (context.action === "last") {
+        if (!rowHomeEnd || index < 0) return total - 1;
+        const info2 = infoFor(context, columns, total);
+        return rowEnd(info2, rowOf(info2, index), total);
+      }
+      return null;
+    }
+    if (index < 0 || index >= total) {
+      return direction === "down" || direction === "right" ? 0 : total - 1;
+    }
+    const info = infoFor(context, columns, total);
+    const row = rowOf(info, index);
+    const start = rowStart(info, row);
+    const end = rowEnd(info, row, total);
+    if (direction === "left" || direction === "right") {
+      const next = index + (direction === "right" ? 1 : -1);
+      if (next >= start && next <= end) return next;
+      if (!context.loop) return index;
+      return direction === "right" ? start : end;
+    }
+    const rowDelta = direction === "down" ? 1 : -1;
+    let targetRow = row + rowDelta;
+    if (targetRow < 0 || targetRow >= info.starts.length) {
+      if (!context.loop) return index;
+      targetRow = targetRow < 0 ? info.starts.length - 1 : 0;
+    }
+    const targetStart = rowStart(info, targetRow);
+    const targetEnd = rowEnd(info, targetRow, total);
+    if (columns > 0 && !maintainColumn) return targetStart;
+    if (columns > 0) {
+      const column = index - start;
+      const candidate = targetStart + column;
+      return candidate <= targetEnd ? candidate : targetEnd;
+    }
+    const current = context.rectOf(items[index]);
+    return nearestInRow(context, targetStart, targetEnd, current.left + current.width / 2);
+    function infoFor(ctx, cols, count) {
+      if (cols > 0) return declaredInfo(count, cols);
+      if (cachedVersion === ctx.version && cachedItems === ctx.items) return cached;
+      cached = computeGridInfo(ctx);
+      cachedVersion = ctx.version;
+      cachedItems = ctx.items;
+      return cached;
+    }
+  };
+}
+function nearestInRow(context, start, end, targetX) {
+  let best = start;
+  let bestDistance = Infinity;
+  for (let i = start; i <= end; i++) {
+    const element = context.items[i];
+    if (!element) continue;
+    const rect = context.rectOf(element);
+    const distance = Math.abs(rect.left + rect.width / 2 - targetX);
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = i;
+    }
+  }
+  return best;
+}
+function directionFromAction(action) {
+  switch (action) {
+    case "up":
+    case "previous":
+      return "up";
+    case "down":
+    case "next":
+      return "down";
+    case "left":
+      return "left";
+    case "right":
+      return "right";
+    default:
+      return null;
+  }
+}
+
+// src/navigation/sequential.ts
+function findNextIndex(total, from, step, loop, clamp = true) {
+  if (total === 0 || step === 0) return -1;
+  if (from < 0 || from >= total) {
+    return step > 0 ? 0 : total - 1;
+  }
+  const next = from + step;
+  if (loop) return (next % total + total) % total;
+  if (next < 0) return clamp ? 0 : -1;
+  if (next >= total) return clamp ? total - 1 : -1;
+  return next;
+}
+function actionDelta(action, direction) {
+  if (direction) {
+    if (direction === "down" || direction === "right") return 1;
+    if (direction === "up" || direction === "left") return -1;
+    return 0;
+  }
+  switch (action) {
+    case "next":
+    case "down":
+    case "right":
+      return 1;
+    case "previous":
+    case "up":
+    case "left":
+      return -1;
+    default:
+      return 0;
+  }
+}
+function createSequentialStrategy(axis = "both") {
+  return (context) => {
+    const { action, direction, index, items, loop } = context;
+    const delta = actionDelta(action, direction);
+    if (delta === 0) return null;
+    const isVerticalAction = direction !== null ? direction === "up" || direction === "down" : action === "up" || action === "down";
+    if (axis === "vertical" && !isVerticalAction && direction !== null) return null;
+    if (axis === "horizontal" && isVerticalAction) return null;
+    return findNextIndex(items.length, index, delta, loop);
+  };
+}
+
+// src/utils/emitter.ts
+var Emitter = class {
+  constructor() {
+    this.handlers = null;
+  }
+  on(event, handler) {
+    if (!this.handlers) this.handlers = /* @__PURE__ */ new Map();
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      this.off(event, handler);
+    };
+  }
+  off(event, handler) {
+    const set = this.handlers?.get(event);
+    if (!set) return;
+    if (handler) set.delete(handler);
+    else set.clear();
+    if (set.size === 0) this.handlers?.delete(event);
+  }
+  emit(event, payload) {
+    const set = this.handlers?.get(event);
+    if (!set || set.size === 0) return;
+    for (const handler of Array.from(set)) {
+      handler(payload);
+    }
+  }
+  clear() {
+    this.handlers?.clear();
+    this.handlers = null;
+  }
+  get size() {
+    if (!this.handlers) return 0;
+    let total = 0;
+    for (const set of this.handlers.values()) total += set.size;
+    return total;
+  }
+};
+
+// 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;
+  }
+};
+
+// src/utils/layout.ts
+var LayoutCache = class {
+  constructor() {
+    this.rects = /* @__PURE__ */ new WeakMap();
+  }
+  rect(element, version) {
+    const cached = this.rects.get(element);
+    if (cached && cached.version === version) return cached.rect;
+    const rect = element.getBoundingClientRect();
+    this.rects.set(element, { version, rect });
+    return rect;
+  }
+};
+
+// 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 "";
+  }
+}
+
+// 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;
+}
+
+// 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);
+}
+
+// src/patterns/shared.ts
+var LANDMARKS = /* @__PURE__ */ new Set(["NAV", "MAIN", "ASIDE", "HEADER", "FOOTER", "FORM", "SECTION", "ARTICLE", "DIALOG"]);
+function acceptsRole(element) {
+  return !element.hasAttribute("role") && !LANDMARKS.has(element.tagName);
+}
+function ensureRole(element, role, enabled) {
+  if (enabled && acceptsRole(element)) element.setAttribute("role", role);
+}
+function ensureItemRoles(container, items, containerRole, itemRole, enabled) {
+  if (!enabled || !container) return;
+  if (container.getAttribute("role") !== containerRole) return;
+  for (let i = 0; i < items.length; i++) ensureRole(items[i], itemRole, true);
+}
+function setAria(element, name, value, enabled) {
+  if (!enabled || !element) return;
+  setAttribute(element, name, value);
+}
+
+// src/patterns/tabs.ts
+var TabsController = class extends NavigationController {
+  constructor(options) {
+    const orientation = options.orientation ?? "horizontal";
+    super(options, {
+      mode: options.mode ?? (orientation === "vertical" ? "vertical" : "horizontal"),
+      loop: options.loop ?? true,
+      defaultKeys: orientation === "vertical" ? TABS_KEYS_VERTICAL : TABS_KEYS_HORIZONTAL
+    });
+    this.panels = [];
+    this.activeValue = -1;
+    this.applying = false;
+    this.initializing = true;
+    this.orientationValue = orientation;
+    this.activationValue = options.activation ?? "automatic";
+    this.manageAria = options.aria !== false;
+    this.activeAttribute = options.activeAttribute ?? "aria-selected";
+    this.panelActiveAttribute = options.panelActiveAttribute ?? "hidden";
+    this.panelSelector = options.panels;
+    this.userOnActivate = options.onActivate;
+    if (this.manageAria && this.container) {
+      ensureRole(this.container, "tablist", true);
+      if (this.container.getAttribute("role") === "tablist") {
+        setAria(this.container, "aria-orientation", this.orientationValue, true);
+      }
+    }
+    this.on("focus", ({ index }) => {
+      if (this.activationValue === "automatic") this.activate(index);
+    });
+    this.on("action", ({ action, index }) => {
+      if (this.activationValue === "manual" && action === "select" && index >= 0) this.activate(index);
+    });
+    this.on("refresh", () => this.refreshPanels());
+    this.refreshPanels();
+    this.decorate();
+    const initial = this.detectInitialIndex();
+    this.applyActive(initial);
+    this.initializing = false;
+  }
+  get activeTab() {
+    return this.activeValue >= 0 ? this.items[this.activeValue] ?? null : null;
+  }
+  get activeIndex() {
+    return this.activeValue;
+  }
+  get orientation() {
+    return this.orientationValue;
+  }
+  get activation() {
+    return this.activationValue;
+  }
+  activate(indexOrElement) {
+    if (indexOrElement === null) {
+      this.applyActive(-1);
+      return;
+    }
+    const index = typeof indexOrElement === "number" ? indexOrElement : this.items.indexOf(indexOrElement);
+    if (index < 0 || index >= this.items.length) return;
+    this.applyActive(index, true);
+  }
+  refresh() {
+    const items = super.refresh();
+    this.refreshPanels();
+    this.decorate();
+    if (this.activeValue >= items.length) this.applyActive(items.length > 0 ? 0 : -1);
+    else this.applyActive(this.activeValue);
+    return items;
+  }
+  ownsAction(action) {
+    return action === "select";
+  }
+  refreshPanels() {
+    if (!this.panelSelector || !this.container) {
+      this.panels = [];
+      return;
+    }
+    let panels = queryItems(this.container, this.panelSelector);
+    if (panels.length === 0) {
+      const scope = this.container.parentElement;
+      if (scope && scope !== this.container.ownerDocument?.documentElement) {
+        panels = queryItems(scope, this.panelSelector);
+      }
+    }
+    this.panels = panels;
+  }
+  decorate() {
+    const items = this.items;
+    for (let i = 0; i < items.length; i++) {
+      const tab = items[i];
+      ensureRole(tab, "tab", this.manageAria);
+      if (!this.manageAria) continue;
+      const tabId = ensureId(tab, "keystra-tab");
+      const panel = this.panels[i];
+      if (!panel) continue;
+      const panelId = ensureId(panel, "keystra-panel");
+      ensureRole(panel, "tabpanel", true);
+      setAria(tab, "aria-controls", panelId, true);
+      setAria(panel, "aria-labelledby", tabId, true);
+    }
+  }
+  detectInitialIndex() {
+    const items = this.items;
+    for (let i = 0; i < items.length; i++) {
+      if (items[i].getAttribute(this.activeAttribute) === "true") return i;
+    }
+    return items.length > 0 ? 0 : -1;
+  }
+  applyActive(index, moveFocus = false) {
+    if (this.applying) return;
+    this.applying = true;
+    try {
+      this.applyActiveNow(index, moveFocus);
+    } finally {
+      this.applying = false;
+    }
+  }
+  applyActiveNow(index, moveFocus) {
+    const items = this.items;
+    const previous = this.activeValue;
+    this.activeValue = index;
+    const writeMarker = this.manageAria || this.activeAttribute !== "aria-selected";
+    const writePanels = this.manageAria;
+    for (let i = 0; i < items.length; i++) {
+      const tab = items[i];
+      const on = i === index;
+      if (writeMarker && tab.getAttribute(this.activeAttribute) !== (on ? "true" : "false")) {
+        tab.setAttribute(this.activeAttribute, on ? "true" : "false");
+      }
+      if (this.manageAria && this.activeAttribute !== "aria-selected") {
+        setAria(tab, "aria-selected", on ? "true" : "false", true);
+      }
+      if (!writePanels) continue;
+      const panel = this.panels[i];
+      if (!panel) continue;
+      if (this.panelActiveAttribute === "hidden") {
+        if (panel.hasAttribute("hidden") === on) panel.toggleAttribute("hidden", !on);
+      } else {
+        panel.setAttribute(this.panelActiveAttribute, on ? "true" : "false");
+      }
+    }
+    if (index >= 0) {
+      if (moveFocus && items[index] !== this.activeElement) this.focusIndex(index);
+      else if (!moveFocus) this.setActiveIndex(index, { focus: false });
+    }
+    if (previous !== index && index >= 0 && !this.initializing) {
+      const element = items[index];
+      if (element) this.userOnActivate?.(element, index);
+    }
+  }
+};
+function createTabs(options = {}) {
+  return new TabsController(options);
+}
+
+// src/patterns/menu.ts
+var MenuController = class extends NavigationController {
+  constructor(options) {
+    super(
+      {
+        typeahead: true,
+        ...options,
+        enabled: false
+      },
+      {
+        mode: options.mode ?? "vertical",
+        loop: options.loop ?? true,
+        defaultKeys: MENU_KEYS
+      }
+    );
+    this.openValue = false;
+    this.unhidden = false;
+    this.closeOnSelect = options.closeOnSelect !== false;
+    this.returnFocusTarget = options.returnFocusTo;
+    this.manageAria = options.aria !== false;
+    this.toggleHiddenValue = options.toggleHidden !== false;
+    this.userOnOpen = options.onOpen;
+    this.userOnClose = options.onClose;
+    if (this.manageAria && this.container) ensureRole(this.container, "menu", true);
+    this.decorateItems();
+    this.on("select", () => {
+      if (this.closeOnSelect) this.close();
+    });
+    this.on("action", ({ action }) => {
+      if (action === "escape") this.close();
+    });
+    this.on("refresh", () => this.decorateItems());
+  }
+  decorateItems() {
+    ensureItemRoles(this.container, this.items, "menu", "menuitem", this.manageAria);
+  }
+  get isOpen() {
+    return this.openValue;
+  }
+  open(options = {}) {
+    if (this.openValue) return;
+    this.openValue = true;
+    this.enable();
+    this.rememberFocus();
+    if (this.toggleHiddenValue && this.container?.hasAttribute("hidden")) {
+      this.container.removeAttribute("hidden");
+      this.unhidden = true;
+    }
+    this.refresh();
+    if (this.manageAria && this.container) this.container.setAttribute("data-keystra-open", "true");
+    const target = options.focus ?? "first";
+    const items = this.items;
+    if (items.length === 0) {
+      this.userOnOpen?.(this);
+      return;
+    }
+    if (target === "current" && this.currentIndex >= 0) {
+      this.focusIndex(this.currentIndex);
+    } else if (target === "last") {
+      this.focusIndex(items.length - 1);
+    } else if (typeof target === "number") {
+      this.focusIndex(Math.max(0, Math.min(target, items.length - 1)));
+    } else {
+      this.focusIndex(0);
+    }
+    this.userOnOpen?.(this);
+  }
+  close(options = {}) {
+    if (!this.openValue) return;
+    this.openValue = false;
+    this.disable();
+    if (this.manageAria && this.container) this.container.removeAttribute("data-keystra-open");
+    if (options.restoreFocus !== false) {
+      const explicit = resolveElement(this.returnFocusTarget, this.container?.ownerDocument ?? null);
+      if (explicit) focusElement(explicit);
+      else this.restoreFocus();
+    }
+    if (this.unhidden) {
+      this.container?.setAttribute("hidden", "");
+      this.unhidden = false;
+    }
+    this.userOnClose?.(this);
+  }
+  toggle() {
+    if (this.openValue) this.close();
+    else this.open();
+  }
+  destroy() {
+    this.openValue = false;
+    super.destroy();
+  }
+  ownsAction(action) {
+    return action === "select" || action === "escape";
+  }
+};
+function createMenu(options = {}) {
+  return new MenuController(options);
+}
+
+// src/patterns/dropdown.ts
+var DEFAULT_OPEN_KEYS = ["Enter", "Space", "ArrowDown", "ArrowUp"];
+var DropdownController = class extends MenuController {
+  constructor(options) {
+    super({ typeahead: true, ...options });
+    this.extra = new EventManager();
+    const doc = this.container?.ownerDocument ?? (typeof document !== "undefined" ? document : null);
+    this.triggerElement = resolveElement(options.trigger, doc);
+    this.manageTriggerAria = options.aria !== false;
+    this.closeOnBlurValue = options.closeOnBlur === true;
+    this.closeOnOutsidePointerValue = options.closeOnOutsidePointer !== false;
+    const openKeys = options.openKeys === void 0 || options.openKeys === null ? DEFAULT_OPEN_KEYS : Array.isArray(options.openKeys) ? options.openKeys : [options.openKeys];
+    this.openMatcher = new KeyMatcher({ open: openKeys });
+    this.menuId = this.container ? ensureId(this.container, "keystra-menu") : null;
+    this.decorateTrigger();
+    this.wireTrigger();
+    this.on("action", ({ action, event }) => {
+      if (action !== "escape") return;
+      event?.preventDefault();
+      this.close();
+    });
+  }
+  get trigger() {
+    return this.triggerElement;
+  }
+  open(options = {}) {
+    const wasOpen = this.isOpen;
+    super.open(options);
+    if (!wasOpen && this.isOpen) this.syncTriggerState();
+  }
+  close(options = {}) {
+    const wasOpen = this.isOpen;
+    super.close({ restoreFocus: false });
+    if (wasOpen && options.restoreFocus !== false && this.triggerElement) {
+      focusElement(this.triggerElement);
+    }
+    if (wasOpen) this.syncTriggerState();
+  }
+  destroy() {
+    this.extra.dispose();
+    this.openMatcher.dispose();
+    if (this.triggerElement && this.manageTriggerAria) {
+      this.triggerElement.removeAttribute("aria-expanded");
+      if (this.menuId) this.triggerElement.removeAttribute("aria-controls");
+    }
+    super.destroy();
+  }
+  decorateTrigger() {
+    const trigger = this.triggerElement;
+    if (!trigger || !this.manageTriggerAria) return;
+    if (!trigger.hasAttribute("aria-haspopup")) trigger.setAttribute("aria-haspopup", "menu");
+    setAria(trigger, "aria-controls", this.menuId, true);
+    this.syncTriggerState();
+  }
+  syncTriggerState() {
+    if (!this.triggerElement || !this.manageTriggerAria) return;
+    this.triggerElement.setAttribute("aria-expanded", this.isOpen ? "true" : "false");
+  }
+  wireTrigger() {
+    const trigger = this.triggerElement;
+    if (!trigger) return;
+    this.extra.add(trigger, "click", () => {
+      this.toggle();
+    });
+    this.extra.add(trigger, "keydown", (rawEvent) => {
+      const event = rawEvent;
+      if (this.isOpen) {
+        if (event.key === "Tab") this.close({ restoreFocus: false });
+        return;
+      }
+      const normalized = normalizeKeyEvent(event);
+      const match = this.openMatcher.match(normalized, this);
+      if (!match?.complete) return;
+      event.preventDefault();
+      this.open({ focus: normalized.key === "ArrowUp" ? "last" : "first" });
+    });
+    if (typeof document !== "undefined") {
+      this.extra.add(document, "keydown", (rawEvent) => {
+        const event = rawEvent;
+        if (event.key !== "Tab" || event.defaultPrevented || !this.isOpen) return;
+        if (contains(this.container, event.target)) this.close();
+      });
+    }
+    if (this.closeOnOutsidePointerValue && typeof document !== "undefined") {
+      this.extra.add(document, "pointerdown", (rawEvent) => {
+        if (!this.isOpen) return;
+        const target = rawEvent.target;
+        if (contains(this.container, target) || contains(this.triggerElement, target)) return;
+        this.close({ restoreFocus: false });
+      });
+    }
+    if (this.closeOnBlurValue && typeof document !== "undefined") {
+      this.extra.add(document, "focusin", (rawEvent) => {
+        if (!this.isOpen) return;
+        const target = rawEvent.target;
+        if (contains(this.container, target) || contains(this.triggerElement, target)) return;
+        this.close({ restoreFocus: false });
+      });
+    }
+  }
+};
+function createDropdown(options = {}) {
+  return new DropdownController(options);
+}
+
+// src/patterns/list.ts
+var ListController = class extends NavigationController {
+  constructor(options) {
+    super(options, {
+      mode: options.mode ?? "vertical",
+      loop: options.loop ?? false,
+      defaultKeys: LIST_KEYS
+    });
+    this.manageAria = options.aria !== false;
+    if (this.manageAria && this.container) {
+      ensureRole(this.container, "listbox", true);
+      if (this.container.getAttribute("role") === "listbox" && this.selectionManager) {
+        const multiple = this.selectionManager.mode === "multiple" || this.selectionManager.mode === "range";
+        setAria(this.container, "aria-multiselectable", multiple ? "true" : null, true);
+      }
+    }
+    this.decorateItems();
+    this.on("refresh", () => this.decorateItems());
+  }
+  decorateItems() {
+    ensureItemRoles(this.container, this.items, "listbox", "option", this.manageAria);
+  }
+};
+function createList(options = {}) {
+  const container = resolveElement(options.container);
+  const aria = options.aria !== false && container !== null && (container.getAttribute("role") === "listbox" || acceptsRole(container));
+  const selection = options.selection ?? { enabled: true, mode: "single", followFocus: true };
+  return new ListController({
+    typeahead: true,
+    ...options,
+    selection: typeof selection === "object" ? { aria, ...selection } : selection && { mode: "single", aria }
+  });
+}
+
+// src/patterns/grid.ts
+var GridController = class extends NavigationController {
+  constructor(options) {
+    super(options, {
+      mode: "grid",
+      loop: options.loop ?? false,
+      columns: options.columns ?? 0,
+      strategy: createGridStrategy({
+        maintainColumn: options.maintainColumn,
+        rowHomeEnd: options.rowHomeEnd
+      })
+    });
+    this.manageAria = options.aria !== false;
+    this.decorateRoles();
+    this.on("refresh", () => this.decorateRoles());
+  }
+  decorateRoles() {
+    const container = this.container;
+    if (!this.manageAria || !container) return;
+    if (container.querySelector("[role='row']") === null) return;
+    ensureRole(container, "grid", true);
+    const items = this.items;
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      if (item.parentElement?.getAttribute("role") === "row") ensureRole(item, "gridcell", true);
+    }
+  }
+  get columns() {
+    if (this.resolved.columns > 0) return this.resolved.columns;
+    const items = this.items;
+    if (items.length === 0) return 0;
+    let columns = 1;
+    const first = items[0];
+    const top = this.rectOf(first).top;
+    for (let i = 1; i < items.length; i++) {
+      if (Math.abs(this.rectOf(items[i]).top - top) < 2) columns++;
+      else break;
+    }
+    return columns;
+  }
+  get rows() {
+    const columns = this.columns;
+    if (columns <= 0) return 0;
+    return Math.ceil(this.items.length / columns);
+  }
+  get position() {
+    const index = this.activeIndex;
+    const columns = this.columns;
+    if (index < 0 || columns <= 0) return { row: -1, column: -1 };
+    return { row: Math.floor(index / columns), column: index % columns };
+  }
+  focusCell(row, column) {
+    const columns = this.columns;
+    if (columns <= 0) return null;
+    const index = row * columns + column;
+    if (index < 0 || index >= this.items.length) return null;
+    return this.focusIndex(index);
+  }
+  rectOf(element) {
+    return this.collection.layout.rect(element, this.collection.version);
+  }
+};
+function createGrid(options = {}) {
+  return new GridController(options);
+}
+
+// src/patterns/tree.ts
+var DEFAULT_ITEM_SELECTOR2 = "[role='treeitem']";
+var DEFAULT_GROUP_SELECTOR = "[role='group']";
+var TreeController = class extends NavigationController {
+  constructor(options) {
+    const hiddenClass = options.hiddenClass;
+    super(
+      {
+        typeahead: true,
+        items: options.items ?? DEFAULT_ITEM_SELECTOR2,
+        ...options,
+        filter: hiddenClass ? (element, index) => {
+          if (options.filter && !options.filter(element, index)) return false;
+          const group = element.parentElement?.closest(`.${hiddenClass}`);
+          return !group;
+        } : options.filter
+      },
+      {
+        mode: options.mode ?? "vertical",
+        loop: options.loop ?? false,
+        defaultKeys: TREE_KEYS
+      }
+    );
+    this.groupSelector = options.groupSelector ?? DEFAULT_GROUP_SELECTOR;
+    this.manageAria = options.aria !== false;
+    this.collapseBehavior = options.collapseBehavior ?? "attribute";
+    this.toggleHiddenValue = options.toggleHidden === true || this.collapseBehavior === "hidden";
+    this.hiddenClassValue = options.hiddenClass;
+    this.userOnExpand = options.onExpand;
+    this.userOnCollapse = options.onCollapse;
+    if (this.manageAria && this.container) ensureRole(this.container, "tree", true);
+    this.decorateItems();
+    this.on("action", ({ action, element }) => {
+      if (!element) return;
+      if (action === "expand") this.handleExpandKey(element);
+      else if (action === "collapse") this.handleCollapseKey(element);
+    });
+  }
+  decorateItems() {
+    ensureItemRoles(this.container, this.items, "tree", "treeitem", this.manageAria);
+    this.on("refresh", () => {
+      ensureItemRoles(this.container, this.items, "tree", "treeitem", this.manageAria);
+    });
+  }
+  isExpandable(element) {
+    if (element.hasAttribute("aria-expanded")) return true;
+    if (element.hasAttribute("data-expandable")) return true;
+    return element.querySelector(this.groupSelector) !== null;
+  }
+  isExpanded(element) {
+    const value = element.getAttribute("aria-expanded");
+    if (value !== null) return value === "true";
+    const group = element.querySelector(this.groupSelector);
+    if (!group) return false;
+    if (this.hiddenClassValue) return !group.classList.contains(this.hiddenClassValue);
+    return !group.hasAttribute("hidden");
+  }
+  expand(elementOrIndex) {
+    const element = this.elementOf(elementOrIndex);
+    if (!element || !this.isExpandable(element)) return;
+    if (this.isExpanded(element)) return;
+    this.setExpanded(element, true);
+  }
+  collapse(elementOrIndex) {
+    const element = this.elementOf(elementOrIndex);
+    if (!element || !this.isExpandable(element)) return;
+    if (!this.isExpanded(element)) return;
+    this.setExpanded(element, false);
+  }
+  toggleExpanded(elementOrIndex) {
+    const element = this.elementOf(elementOrIndex);
+    if (!element || !this.isExpandable(element)) return;
+    this.setExpanded(element, !this.isExpanded(element));
+  }
+  expandAll() {
+    const visited = /* @__PURE__ */ new Set();
+    for (let pending = true; pending; ) {
+      pending = false;
+      for (const element of this.items) {
+        if (visited.has(element)) continue;
+        visited.add(element);
+        if (!this.isExpandable(element) || this.isExpanded(element)) continue;
+        this.setExpanded(element, true);
+        pending = true;
+      }
+    }
+  }
+  collapseAll() {
+    for (const element of this.items) if (this.isExpandable(element)) this.setExpanded(element, false);
+  }
+  level(element) {
+    let depth = 0;
+    let node = element.parentElement;
+    while (node && node !== this.container) {
+      if (this.matchesGroup(node)) depth++;
+      node = node.parentElement;
+    }
+    return depth;
+  }
+  parent(element) {
+    const items = this.items;
+    let node = element.parentElement;
+    while (node && node !== this.container) {
+      if (items.indexOf(node) !== -1) return node;
+      node = node.parentElement;
+    }
+    return null;
+  }
+  elementOf(elementOrIndex) {
+    if (elementOrIndex === void 0) return this.activeElement;
+    if (typeof elementOrIndex === "number") return this.items[elementOrIndex] ?? null;
+    return elementOrIndex;
+  }
+  matchesGroup(node) {
+    if (typeof node.matches === "function") {
+      try {
+        return node.matches(this.groupSelector);
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+  setExpanded(element, expanded) {
+    if (this.collapseBehavior !== "none") {
+      setAria(element, "aria-expanded", expanded ? "true" : "false", this.manageAria);
+    }
+    const group = element.querySelector(this.groupSelector);
+    if (group) {
+      if (this.toggleHiddenValue) {
+        if (group.hasAttribute("hidden") === expanded) group.toggleAttribute("hidden", !expanded);
+      }
+      if (this.hiddenClassValue) group.classList.toggle(this.hiddenClassValue, !expanded);
+    }
+    this.refresh();
+    if (expanded) this.userOnExpand?.(element, this.items.indexOf(element));
+    else this.userOnCollapse?.(element, this.items.indexOf(element));
+  }
+  handleExpandKey(element) {
+    if (!this.isExpandable(element)) return;
+    if (!this.isExpanded(element)) {
+      this.setExpanded(element, true);
+      return;
+    }
+    const index = this.items.indexOf(element);
+    if (index !== -1 && index + 1 < this.items.length) this.focusIndex(index + 1);
+  }
+  handleCollapseKey(element) {
+    if (this.isExpandable(element) && this.isExpanded(element)) {
+      this.setExpanded(element, false);
+      return;
+    }
+    const parent = this.parent(element);
+    if (parent) this.focusElement(parent);
+  }
+};
+function createTree(options = {}) {
+  return new TreeController(options);
+}
+
+// src/patterns/command-palette.ts
+var CommandPaletteController = class extends NavigationController {
+  constructor(options) {
+    const doc = typeof document !== "undefined" ? document : null;
+    const containerElement = resolveElement(options.container, doc);
+    const input = resolveElement(options.input, doc) ?? containerElement?.querySelector(
+      "input:not([type='hidden']), textarea"
+    ) ?? null;
+    super(
+      {
+        activeDescendant: input ?? true,
+        ...options
+      },
+      {
+        mode: options.mode ?? "vertical",
+        loop: options.loop ?? true,
+        defaultKeys: COMMAND_PALETTE_KEYS,
+        listenTarget: input ?? containerElement ?? doc
+      }
+    );
+    this.extra = new EventManager();
+    this.openValue = false;
+    this.listId = null;
+    this.listElement = null;
+    this.inputElement = input;
+    this.manageAria = options.aria !== false;
+    this.toggleHiddenValue = options.toggleHidden !== false;
+    this.userOnQuery = options.onQuery;
+    this.userOnSubmit = options.onSubmit;
+    this.userOnCancel = options.onCancel;
+    if (options.openKeys && typeof document !== "undefined") {
+      const bindings = Array.isArray(options.openKeys) ? options.openKeys : [options.openKeys];
+      this.openMatcher = new KeyMatcher({ open: bindings });
+      this.extra.add(document, "keydown", (rawEvent) => {
+        const event = rawEvent;
+        const match = this.openMatcher.match(normalizeKeyEvent(event), this);
+        if (!match?.complete) return;
+        event.preventDefault();
+        this.toggle();
+      });
+    } else {
+      this.openMatcher = null;
+    }
+    this.listElement = resolveElement(options.list, doc) ?? this.container;
+    if (this.manageAria && this.listElement) {
+      ensureRole(this.listElement, "listbox", true);
+      this.listId = ensureId(this.listElement, "keystra-palette");
+    }
+    if (this.manageAria && this.inputElement) {
+      ensureRole(this.inputElement, "combobox", true);
+      setAria(this.inputElement, "aria-controls", this.listId, true);
+      setAria(this.inputElement, "aria-expanded", "false", true);
+      if (!this.inputElement.hasAttribute("aria-autocomplete")) {
+        this.inputElement.setAttribute("aria-autocomplete", "list");
+      }
+      if (options.placeholder && !this.inputElement.hasAttribute("placeholder")) {
+        this.inputElement.setAttribute("placeholder", options.placeholder);
+      }
+    }
+    this.wireInput();
+    this.decorateItems();
+    this.on("refresh", () => this.decorateItems());
+    this.on("select", ({ element }) => {
+      this.userOnSubmit?.(element ?? null, this.query);
+    });
+    this.on("action", ({ action, event }) => {
+      if (action !== "escape") return;
+      event?.preventDefault();
+      this.userOnCancel?.();
+      this.close();
+    });
+  }
+  get isOpen() {
+    return this.openValue;
+  }
+  get query() {
+    return this.inputElement?.value ?? "";
+  }
+  get input() {
+    return this.inputElement;
+  }
+  open() {
+    if (this.openValue) return;
+    this.openValue = true;
+    this.enable();
+    this.rememberFocus();
+    if (this.container && this.toggleHiddenValue && this.container.hasAttribute("hidden")) {
+      this.container.removeAttribute("hidden");
+    }
+    if (this.inputElement) {
+      focusElement(this.inputElement);
+      if (typeof this.inputElement.select === "function") this.inputElement.select();
+    }
+    this.refresh();
+    this.setActiveIndex(0, { focus: false });
+    setAria(this.inputElement, "aria-expanded", "true", this.manageAria);
+  }
+  close(options = {}) {
+    if (!this.openValue) return;
+    this.openValue = false;
+    this.disable();
+    if (this.container && this.toggleHiddenValue && !this.container.hasAttribute("hidden")) {
+      this.container.setAttribute("hidden", "");
+    }
+    setAria(this.inputElement, "aria-expanded", "false", this.manageAria);
+    if (options.restoreFocus !== false) this.restoreFocus();
+  }
+  toggle() {
+    if (this.openValue) this.close();
+    else this.open();
+  }
+  setQuery(query) {
+    if (!this.inputElement) return;
+    if (this.inputElement.value === query) return;
+    this.inputElement.value = query;
+    this.userOnQuery?.(query);
+  }
+  destroy() {
+    this.extra.dispose();
+    this.openMatcher?.dispose();
+    if (this.inputElement && this.manageAria) {
+      this.inputElement.removeAttribute("aria-expanded");
+      if (this.listId) this.inputElement.removeAttribute("aria-controls");
+    }
+    super.destroy();
+  }
+  ownsAction(action) {
+    return action === "select" || action === "escape";
+  }
+  runAction(action, event, match) {
+    if (super.runAction(action, event, match)) return true;
+    if (action !== "select") return false;
+    this.userOnSubmit?.(null, this.query);
+    return true;
+  }
+  decorateItems() {
+    ensureItemRoles(this.listElement, this.items, "listbox", "option", this.manageAria);
+  }
+  wireInput() {
+    const input = this.inputElement;
+    if (!input) return;
+    this.extra.add(input, "input", () => {
+      this.userOnQuery?.(input.value);
+      this.refresh();
+      this.setActiveIndex(0, { focus: false });
+    });
+  }
+};
+function createCommandPalette(options = {}) {
+  return new CommandPaletteController(options);
+}
+
+// src/patterns/roving-focus.ts
+function createRovingFocus(options = {}) {
+  const instance = createKeystra({
+    keys: options.mode === void 0 ? ROVING_KEYS : void 0,
+    loop: true,
+    roving: true,
+    ...options
+  });
+  const items = instance.items;
+  if (items.length === 0) return instance;
+  let initial = options.initialIndex ?? -1;
+  if (initial < 0) {
+    for (let i = 0; i < items.length; i++) {
+      if (items[i].getAttribute("tabindex") === "0") {
+        initial = i;
+        break;
+      }
+    }
+  }
+  if (initial > 0) instance.setActiveIndex(initial, { focus: false });
+  return instance;
+}
+
+exports.DropdownController = DropdownController;
+exports.MenuController = MenuController;
+exports.createCommandPalette = createCommandPalette;
+exports.createDropdown = createDropdown;
+exports.createGrid = createGrid;
+exports.createList = createList;
+exports.createMenu = createMenu;
+exports.createRovingFocus = createRovingFocus;
+exports.createTabs = createTabs;
+exports.createTree = createTree;
+exports.ensureId = ensureId;
+exports.ensureRole = ensureRole;
+exports.setAria = setAria;