@enigmax/primitives 0.22.0 → 0.23.0

package/dist/chunk-WSQC3PCC.js

@@ -0,0 +1,466 @@
+import { shortcutList, matchesShortcut } from './chunk-4VUHQFAT.js';
+
+// src/core/selection.ts
+var DEFAULT_SELECTION_SHORTCUTS = {
+  selectAll: "Mod+A",
+  clear: "Escape",
+  invert: false,
+  moveUp: "ArrowUp",
+  moveDown: "ArrowDown",
+  moveLeft: "ArrowLeft",
+  moveRight: "ArrowRight",
+  moveHome: "Home",
+  moveEnd: "End",
+  movePageUp: "PageUp",
+  movePageDown: "PageDown",
+  extendUp: "Shift+ArrowUp",
+  extendDown: "Shift+ArrowDown",
+  extendLeft: "Shift+ArrowLeft",
+  extendRight: "Shift+ArrowRight",
+  extendHome: "Shift+Home",
+  extendEnd: "Shift+End",
+  extendPageUp: "Shift+PageUp",
+  extendPageDown: "Shift+PageDown",
+  // The cursor moving WITHOUT the selection following, which is how a file manager lets you
+  // reach a distant row and add it with Ctrl+Space rather than starting again.
+  cursorUp: "Mod+ArrowUp",
+  cursorDown: "Mod+ArrowDown",
+  toggleCursor: "Mod+Space",
+  open: "Enter",
+  rename: "F2",
+  delete: "Delete",
+  deletePermanent: "Shift+Delete",
+  copy: "Mod+C",
+  cut: "Mod+X",
+  paste: "Mod+V"
+};
+var OWNED = /* @__PURE__ */ new Set([
+  "selectAll",
+  "clear",
+  "invert",
+  "moveUp",
+  "moveDown",
+  "moveLeft",
+  "moveRight",
+  "moveHome",
+  "moveEnd",
+  "movePageUp",
+  "movePageDown",
+  "extendUp",
+  "extendDown",
+  "extendLeft",
+  "extendRight",
+  "extendHome",
+  "extendEnd",
+  "extendPageUp",
+  "extendPageDown",
+  "cursorUp",
+  "cursorDown",
+  "toggleCursor"
+]);
+function createSelection(options = {}) {
+  let opts = { ...options };
+  let items = opts.items ?? [];
+  let selected = /* @__PURE__ */ new Set();
+  let cursor = -1;
+  let anchor = -1;
+  let rangeBase = null;
+  let marqueeBase = null;
+  let destroyed = false;
+  const listeners = /* @__PURE__ */ new Set();
+  function idOf(index) {
+    const item = items[index];
+    if (item === void 0) return null;
+    return opts.getId ? opts.getId(item, index) : String(index);
+  }
+  function selectable(index) {
+    const item = items[index];
+    if (item === void 0) return false;
+    return !opts.disabled?.(item, index);
+  }
+  function multiple() {
+    return opts.multiple ?? true;
+  }
+  function columns() {
+    return Math.max(1, opts.columns ?? 1);
+  }
+  function orderedIds() {
+    const ids = [];
+    for (let index = 0; index < items.length; index++) {
+      const id = idOf(index);
+      if (id !== null && selected.has(id)) ids.push(id);
+    }
+    return ids;
+  }
+  function selectedItems() {
+    const chosen = [];
+    for (let index = 0; index < items.length; index++) {
+      const id = idOf(index);
+      if (id !== null && selected.has(id)) chosen.push(items[index]);
+    }
+    return chosen;
+  }
+  function snapshot() {
+    const ids = orderedIds();
+    let count = 0;
+    for (let index = 0; index < items.length; index++) if (selectable(index)) count++;
+    return {
+      selected: ids,
+      selectedSet: new Set(ids),
+      items: selectedItems(),
+      cursor,
+      anchor,
+      count: ids.length,
+      allSelected: count > 0 && ids.length === count,
+      partiallySelected: ids.length > 0 && ids.length < count,
+      marquee: marqueeBase !== null
+    };
+  }
+  function summary() {
+    let count = 0;
+    for (let index = 0; index < items.length; index++) if (selectable(index)) count++;
+    return `${cursor}:${anchor}:${count}:${orderedIds().join("\0")}`;
+  }
+  let reported = [];
+  function emit() {
+    const state = snapshot();
+    opts.onChange?.(state);
+    for (const listener of listeners) listener(state);
+    const ids = state.selected;
+    if (ids.length !== reported.length || ids.some((id, index) => id !== reported[index])) {
+      reported = ids;
+      opts.onSelectionChange?.(ids, state.items);
+    }
+  }
+  function replace(ids) {
+    selected = new Set(ids);
+  }
+  function nextEnabled(from, step) {
+    for (let index = from; index >= 0 && index < items.length; index += step) {
+      if (selectable(index)) return index;
+    }
+    return -1;
+  }
+  function rangeIds(from, to) {
+    const [low, high] = from < to ? [from, to] : [to, from];
+    const ids = [];
+    for (let index = low; index <= high; index++) {
+      if (!selectable(index)) continue;
+      const id = idOf(index);
+      if (id !== null) ids.push(id);
+    }
+    return ids;
+  }
+  function applyRange(index, additive) {
+    const from = anchor >= 0 ? anchor : index;
+    const ids = rangeIds(from, index);
+    if (additive) {
+      rangeBase = rangeBase ?? new Set(selected);
+      replace([...rangeBase, ...ids]);
+    } else {
+      rangeBase = null;
+      replace(ids);
+    }
+    cursor = index;
+  }
+  function table() {
+    if (opts.shortcuts === false) return {};
+    return { ...DEFAULT_SELECTION_SHORTCUTS, ...opts.shortcuts ?? {} };
+  }
+  function commandFor(event) {
+    const bindings = table();
+    let match = null;
+    for (const [command, spec] of Object.entries(bindings)) {
+      if (spec === false || spec == null) continue;
+      const hit = shortcutList(spec).find((shortcut) => matchesShortcut(event, shortcut));
+      if (!hit) continue;
+      const length = specificity(hit);
+      if (!match || length > match.length) match = { command, length };
+    }
+    return match?.command ?? null;
+  }
+  function specificity(shortcut) {
+    return Number(Boolean(shortcut.mod)) + Number(Boolean(shortcut.ctrl)) + Number(Boolean(shortcut.meta)) + Number(Boolean(shortcut.shift)) + Number(Boolean(shortcut.alt));
+  }
+  function perform(command) {
+    const step = columns();
+    const page = Math.max(1, opts.page ?? 10);
+    switch (command) {
+      case "selectAll":
+        instance.selectAll();
+        return true;
+      case "clear":
+        instance.clear();
+        return true;
+      case "invert":
+        instance.invert();
+        return true;
+      case "moveUp":
+        instance.moveCursor(-step);
+        return true;
+      case "moveDown":
+        instance.moveCursor(step);
+        return true;
+      case "moveLeft":
+        instance.moveCursor(-1);
+        return true;
+      case "moveRight":
+        instance.moveCursor(1);
+        return true;
+      case "moveHome":
+        instance.moveCursor(-items.length);
+        return true;
+      case "moveEnd":
+        instance.moveCursor(items.length);
+        return true;
+      case "movePageUp":
+        instance.moveCursor(-page * step);
+        return true;
+      case "movePageDown":
+        instance.moveCursor(page * step);
+        return true;
+      case "extendUp":
+        instance.moveCursor(-step, true);
+        return true;
+      case "extendDown":
+        instance.moveCursor(step, true);
+        return true;
+      case "extendLeft":
+        instance.moveCursor(-1, true);
+        return true;
+      case "extendRight":
+        instance.moveCursor(1, true);
+        return true;
+      case "extendHome":
+        instance.moveCursor(-items.length, true);
+        return true;
+      case "extendEnd":
+        instance.moveCursor(items.length, true);
+        return true;
+      case "extendPageUp":
+        instance.moveCursor(-page * step, true);
+        return true;
+      case "extendPageDown":
+        instance.moveCursor(page * step, true);
+        return true;
+      case "cursorUp":
+        instance.moveCursor(-step, false, true);
+        return true;
+      case "cursorDown":
+        instance.moveCursor(step, false, true);
+        return true;
+      case "toggleCursor":
+        if (cursor >= 0) instance.toggle(cursor);
+        return true;
+      default:
+        return false;
+    }
+  }
+  const instance = {
+    get state() {
+      return snapshot();
+    },
+    click(index, modifiers = {}) {
+      if (destroyed || !selectable(index)) return;
+      const mod = Boolean(modifiers.ctrlKey || modifiers.metaKey);
+      const shift = Boolean(modifiers.shiftKey) && multiple();
+      if (shift) {
+        applyRange(index, mod && multiple());
+        emit();
+        return;
+      }
+      rangeBase = null;
+      if (mod && multiple()) {
+        this.toggle(index);
+        return;
+      }
+      const id = idOf(index);
+      if (id === null) return;
+      replace([id]);
+      cursor = index;
+      anchor = index;
+      emit();
+    },
+    keyDown(event) {
+      if (destroyed) return false;
+      const command = commandFor(event);
+      if (!command) return false;
+      const targets = selected.size > 0 ? selectedItems() : cursor >= 0 && items[cursor] !== void 0 ? [items[cursor]] : [];
+      const ids = selected.size > 0 ? orderedIds() : cursor >= 0 ? [idOf(cursor)].filter((id) => id !== null) : [];
+      let prevented = false;
+      const report = {
+        command,
+        items: targets,
+        ids,
+        cursor: cursor >= 0 ? items[cursor] ?? null : null,
+        cursorIndex: cursor,
+        event,
+        preventDefault() {
+          prevented = true;
+          report.defaultPrevented = true;
+        },
+        defaultPrevented: false
+      };
+      opts.onCommand?.(report);
+      if (!prevented) perform(command);
+      return OWNED.has(command) || opts.onCommand !== void 0;
+    },
+    select(ids) {
+      if (destroyed) return;
+      replace(ids);
+      emit();
+    },
+    selectIndex(index, additive = false) {
+      if (destroyed || !selectable(index)) return;
+      const id = idOf(index);
+      if (id === null) return;
+      if (additive && multiple()) selected.add(id);
+      else replace([id]);
+      cursor = index;
+      anchor = index;
+      emit();
+    },
+    toggle(index) {
+      if (destroyed || !selectable(index)) return;
+      const id = idOf(index);
+      if (id === null) return;
+      if (!multiple()) {
+        replace([id]);
+      } else if (selected.has(id)) selected.delete(id);
+      else selected.add(id);
+      cursor = index;
+      anchor = index;
+      emit();
+    },
+    selectRange(index, additive = false) {
+      if (destroyed || !selectable(index) || !multiple()) return;
+      applyRange(index, additive);
+      emit();
+    },
+    selectAll() {
+      if (destroyed || !multiple()) return;
+      const ids = [];
+      for (let index = 0; index < items.length; index++) {
+        if (!selectable(index)) continue;
+        const id = idOf(index);
+        if (id !== null) ids.push(id);
+      }
+      replace(ids);
+      emit();
+    },
+    clear() {
+      if (destroyed || selected.size === 0) return;
+      selected = /* @__PURE__ */ new Set();
+      rangeBase = null;
+      emit();
+    },
+    invert() {
+      if (destroyed || !multiple()) return;
+      const next = /* @__PURE__ */ new Set();
+      for (let index = 0; index < items.length; index++) {
+        if (!selectable(index)) continue;
+        const id = idOf(index);
+        if (id !== null && !selected.has(id)) next.add(id);
+      }
+      selected = next;
+      emit();
+    },
+    moveCursor(delta, extend = false, carry = false) {
+      if (destroyed || items.length === 0) return;
+      const from = cursor >= 0 ? cursor : anchor >= 0 ? anchor : delta > 0 ? -1 : items.length;
+      const wanted = Math.max(0, Math.min(items.length - 1, from + delta));
+      const forward = delta >= 0 ? 1 : -1;
+      const ahead = nextEnabled(wanted, forward);
+      const next = ahead >= 0 ? ahead : nextEnabled(wanted, -forward);
+      if (next < 0) return;
+      if (extend && multiple()) {
+        applyRange(next, false);
+        emit();
+        return;
+      }
+      cursor = next;
+      if (carry) {
+        emit();
+        return;
+      }
+      const id = idOf(next);
+      if (id === null) return;
+      replace([id]);
+      anchor = next;
+      rangeBase = null;
+      emit();
+    },
+    setCursor(index) {
+      if (destroyed || index === cursor) return;
+      if (index < -1 || index >= items.length) return;
+      cursor = index;
+      emit();
+    },
+    targets(index) {
+      const id = idOf(index);
+      const item = items[index];
+      if (item === void 0) return selectedItems();
+      return id !== null && selected.has(id) ? selectedItems() : [item];
+    },
+    beginMarquee(additive = false) {
+      if (destroyed || !multiple()) return;
+      marqueeBase = additive ? new Set(selected) : /* @__PURE__ */ new Set();
+      if (!additive && selected.size > 0) selected = /* @__PURE__ */ new Set();
+      emit();
+    },
+    marqueeTo(indices) {
+      if (destroyed || marqueeBase === null) return;
+      const next = new Set(marqueeBase);
+      for (const index of indices) {
+        if (!selectable(index)) continue;
+        const id = idOf(index);
+        if (id !== null) next.add(id);
+      }
+      if (next.size === selected.size && [...next].every((id) => selected.has(id))) return;
+      selected = next;
+      emit();
+    },
+    endMarquee() {
+      if (destroyed || marqueeBase === null) return;
+      marqueeBase = null;
+      emit();
+    },
+    bindings() {
+      return table();
+    },
+    binding(command) {
+      return table()[command] ?? false;
+    },
+    update(next) {
+      if (destroyed) return;
+      const before = summary();
+      const hadItems = next.items !== void 0;
+      opts = { ...opts, ...next };
+      if (hadItems) {
+        items = next.items ?? [];
+        const live = /* @__PURE__ */ new Set();
+        for (let index = 0; index < items.length; index++) {
+          const id = idOf(index);
+          if (id !== null) live.add(id);
+        }
+        for (const id of selected) if (!live.has(id)) selected.delete(id);
+        if (cursor >= items.length) cursor = items.length - 1;
+        if (anchor >= items.length) anchor = items.length - 1;
+      }
+      if (summary() !== before) emit();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      destroyed = true;
+      listeners.clear();
+    }
+  };
+  return instance;
+}
+
+export { DEFAULT_SELECTION_SHORTCUTS, createSelection };

package/dist/context-menu-D3FtTn7v.d.ts

@@ -0,0 +1,174 @@
+import { F as FuseConstructor, c as SearchOptions } from './search-DYgqRp37.js';
+
+/**
+ * The parts of a context menu that are not rendering: which branch is open, where the
+ * highlight is inside it, what a submenu's rows are once they have been fetched, and which
+ * of those rows survived the filter.
+ *
+ * Framework-agnostic like every other core here, and for the same reason: the arithmetic of
+ * a menu is not React. What IS specific to this one is that a menu is a TREE and a select is
+ * a list, so everything below is keyed by a PATH - the list of item ids from the root down to
+ * the open submenu - rather than by an index.
+ *
+ * The behaviour it copies is the Windows one, deliberately: a right-click opens it at the
+ * pointer, a submenu opens after a beat of hovering and closes after a beat of leaving,
+ * arrows walk the rows and skip everything that cannot be chosen, Right opens a submenu and
+ * Left goes back, and typing jumps to a row.
+ */
+
+/** A row that does something. The default kind, so `type` can be left off. */
+interface ContextMenuAction {
+    type?: "item";
+    /** Unique among its SIBLINGS. The path down the tree is built from these. */
+    id: string;
+    label: string;
+    /** A second line under the label, for a row whose consequence is not obvious. */
+    description?: string;
+    /** Anything the renderer can draw - a node, a URL, a name. `unknown` because a core cannot know. */
+    icon?: unknown;
+    /**
+     * Printed on the right, the way every desktop menu prints it: `"Mod+C"`, `"F2"`,
+     * `"Delete"`. Written by `shortcutTokens` for the platform it is rendered on, so one
+     * spec is `⌘C` on a Mac and `Ctrl+C` elsewhere.
+     */
+    shortcut?: string;
+    /** Listed, announced as unavailable, never highlighted and never invoked. */
+    disabled?: boolean;
+    /** Deletes something. Rendered in the destructive colour and reported as such. */
+    destructive?: boolean;
+    /** A checkable row: a tick, or a radio dot when `group` is set. */
+    checked?: boolean;
+    /** Rows carrying the same group render together under its name, and check as a radio set. */
+    group?: string;
+    /** Extra words the filter should match. */
+    keywords?: string[];
+    /** A heading over this row's submenu. See `ContextMenuOptions.title` for what it is for. */
+    title?: string;
+    /** A submenu, known up front. An empty list is not a submenu: the row keeps no arrow. */
+    items?: readonly ContextMenuEntry[];
+    /**
+     * A submenu fetched on demand, once. What it returns is cached under this row's path for
+     * `cacheMs`, so reopening the branch shows the rows immediately instead of spinning
+     * again - which is the whole reason a slow submenu is bearable.
+     */
+    loadItems?: () => Promise<readonly ContextMenuEntry[]>;
+    /** Put a filter in this submenu. `"auto"` (the default) adds one from `SEARCHABLE_FROM` rows. */
+    searchable?: boolean | "auto";
+    /** Anything the caller wants back in `onSelect`. */
+    data?: unknown;
+}
+/** A rule between two blocks of rows. Never highlighted, never counted by the keyboard. */
+interface ContextMenuSeparator {
+    type: "separator";
+    id?: string;
+}
+/** A caption over a block of rows. Same rules as a separator: visible, unreachable. */
+interface ContextMenuLabel {
+    type: "label";
+    id?: string;
+    label: string;
+}
+type ContextMenuEntry = ContextMenuAction | ContextMenuSeparator | ContextMenuLabel;
+/** Whether an entry is a row the keyboard and the pointer can land on. */
+declare function isAction(entry: ContextMenuEntry): entry is ContextMenuAction;
+/** The fields the filter reads when the caller does not say. */
+declare const CONTEXT_MENU_SEARCH_KEYS: string[];
+/** Where a menu was opened. Viewport coordinates, which is what a pointer event reports. */
+interface ContextMenuPoint {
+    x: number;
+    y: number;
+}
+/** One open level: the root, then one per submenu below it. */
+interface ContextMenuLevel {
+    /** Ids from the root down to the item that opened this level. Empty for the root. */
+    path: string[];
+    /** A heading over the rows, or null. Also the panel's accessible name. */
+    title: string | null;
+    /** Every entry at this level, separators and labels included. */
+    entries: ContextMenuEntry[];
+    /** What the panel shows: the entries, or what survived the filter. */
+    visible: ContextMenuEntry[];
+    /** Index into `visible`. -1 when nothing is highlighted. */
+    active: number;
+    query: string;
+    /** Whether this level draws a filter field. */
+    searchable: boolean;
+    /** An awaited submenu that has not answered yet. */
+    loading: boolean;
+    /** What the load rejected with, so the level can say so instead of staying empty. */
+    error: Error | null;
+}
+interface ContextMenuState {
+    open: boolean;
+    /** Where it was opened, in viewport coordinates. Null while closed. */
+    point: ContextMenuPoint | null;
+    /** The root level first, then one per open submenu. */
+    levels: ContextMenuLevel[];
+}
+interface ContextMenuOptions {
+    items?: readonly ContextMenuEntry[];
+    /**
+     * A heading over the rows, naming what the menu is acting ON - the file that was
+     * right-clicked, or "12 items selected". A menu opened at the pointer is the one surface
+     * with no context around it, so without this the rows are the only clue about what they
+     * will happen to.
+     */
+    title?: string;
+    /** Fuse.js's constructor, for fuzzy filtering. Omit it for the built-in matcher. */
+    fuse?: FuseConstructor;
+    fuseOptions?: Record<string, unknown>;
+    matcher?: SearchOptions<ContextMenuEntry>["matcher"];
+    searchKeys?: string[];
+    /** How long a fetched submenu stays cached. 0 refetches every time. Default 5 minutes. */
+    cacheMs?: number;
+    /** Every state change. */
+    onChange?: (state: ContextMenuState) => void;
+    /** A row was invoked. The menu has already closed unless the row keeps it open. */
+    onSelect?: (item: ContextMenuAction, path: string[]) => void;
+    onOpenChange?: (open: boolean) => void;
+}
+interface ContextMenuInstance {
+    readonly state: ContextMenuState;
+    /**
+     * Open at a point, or reopen somewhere else - a second right-click MOVES the menu.
+     *
+     * Returns whether it opened. A menu with no rows to show does NOT open: an empty box at
+     * the pointer says nothing, and refusing here is what lets the trigger leave the press
+     * alone so the browser's own menu appears instead of nothing at all.
+     */
+    open(point: ContextMenuPoint): boolean;
+    close(): void;
+    /** Move the highlight inside the deepest open level, skipping what cannot be chosen. */
+    move(key: ContextMenuMoveKey): void;
+    setActive(level: number, index: number): void;
+    setQuery(level: number, query: string): void;
+    /**
+     * Open the submenu of the row at `index` in `level`, closing any deeper branch.
+     *
+     * `focus` highlights its first row, which is what the KEYBOARD needs and what a pointer
+     * must not do: a row that looks hovered before the pointer arrives reads as the menu
+     * having chosen for you. Default false, so hovering is the plain case.
+     */
+    openSubmenu(level: number, index: number, focus?: boolean): void;
+    /** Close every level below `level`. */
+    closeBelow(level: number): void;
+    /** Invoke a row: reports it, and closes unless it is disabled or opens a submenu. */
+    select(level: number, index: number): void;
+    /** Invoke whatever is highlighted in the deepest open level. */
+    selectActive(): void;
+    /** Right on a row with a submenu opens it; on any other row it does nothing. */
+    enterSubmenu(): void;
+    /** Left closes the deepest submenu and puts the highlight back on the row that opened it. */
+    leaveSubmenu(): void;
+    /** Jump to the row starting with what was typed, the way a desktop menu does. */
+    typeahead(character: string): void;
+    /** Drop what a fetched submenu returned, so the next open asks again. */
+    invalidate(path?: string[]): void;
+    update(options: Partial<ContextMenuOptions>): void;
+    subscribe(listener: (state: ContextMenuState) => void): () => void;
+    destroy(): void;
+}
+type ContextMenuMoveKey = "ArrowDown" | "ArrowUp" | "Home" | "End" | "PageDown" | "PageUp";
+declare function createContextMenu(options?: ContextMenuOptions): ContextMenuInstance;
+
+export { CONTEXT_MENU_SEARCH_KEYS as C, type ContextMenuAction as a, type ContextMenuEntry as b, type ContextMenuInstance as c, type ContextMenuLabel as d, type ContextMenuLevel as e, type ContextMenuMoveKey as f, type ContextMenuOptions as g, type ContextMenuPoint as h, type ContextMenuSeparator as i, type ContextMenuState as j, createContextMenu as k, isAction as l };

package/dist/{index-BHpOZncw.d.ts → index-DQNnohoo.d.ts}

@@ -1,5 +1,5 @@
 import { ReactNode, ComponentPropsWithoutRef } from 'react';
-import { c as SearchOptions, F as FuseConstructor, b as SearchMatch } from './search-BD9-5O5U.js';
+import { c as SearchOptions, F as FuseConstructor, b as SearchMatch } from './search-DYgqRp37.js';
 import { G as GeneratePasswordOptions, E as EstimateOptions, b as PasswordStrengthReport } from './password-C8lG4Zm9.js';
 
 /**

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { M as MarqueeHover, a as MarqueeInstance, b as MarqueeOptions, c as createMarquee } from './marquee-CJ3Uwy3E.js';
 export { I as InputAction, a as InputActionState, b as InputIcon, c as InputInstance, d as InputOptions, e as createInput } from './input-BwXjFenq.js';
-export { F as FuseConstructor, a as FuseLike, S as SearchInstance, b as SearchMatch, c as SearchOptions, d as createSearch, s as subsequenceMatcher } from './search-BD9-5O5U.js';
+export { F as FuseConstructor, a as FuseLike, S as SearchInstance, b as SearchMatch, c as SearchOptions, d as createSearch, s as shortenQuery, e as subsequenceMatcher } from './search-DYgqRp37.js';
 export { B as ButtonCooldown, a as ButtonElement, b as ButtonInstance, c as ButtonOptions, d as ButtonState, e as createButton } from './button-CaXaqG_K.js';
 export { E as EstimateOptions, G as GeneratePasswordOptions, P as PasswordAlphabet, a as PasswordScore, b as PasswordStrengthReport, e as estimatePasswordStrength, g as generatePassword } from './password-C8lG4Zm9.js';
 export { N as Notification, a as NotificationAction, b as NotificationInput, c as NotificationTone, d as Notifications, e as NotificationsOptions, P as PromiseMessages, f as createNotifications } from './notifications-BpVV6sel.js';
@@ -8,6 +8,10 @@ export { N as NetworkMonitor, a as NetworkState, S as SERVER_NETWORK_STATE, c as
 export { R as RelativeTimeFormat, a as RelativeTimeOptions, b as RelativeTimePrecision, c as RelativeTimeStyle, d as RelativeTimeTense, e as RelativeTimeView, f as ensureZone, n as normalizeDate, p as parseDuration, r as relativeTimeAttributes, g as relativeTimeView } from './relative-time-YpRTG7YH.js';
 export { F as FLAG_CDN, a as FLAG_RATIO, b as FlagConfig, c as FlagFormat, d as FlagOptions, e as FlagShape, f as FlagSource, g as FlagView, h as configureFlags, i as flagAttributes, j as flagConfig, k as flagName, l as flagSrc, m as flagView, n as normalizeFlagCode, r as resetFlagConfig } from './flags-BQU1V9rE.js';
 export { P as PaletteKey, a as PositionedRow, R as RecentEntry, b as RecentStore, c as RecentStoreOptions, d as RowGroup, e as createRecentStore, g as groupRows, i as isPaletteShortcut, m as moveActive, r as recentKey, s as shortcutLabel } from './palette-D7iuQh_T.js';
+export { S as SELECT_SEARCH_KEYS, a as SelectInstance, b as SelectMoveKey, c as SelectOption, d as SelectOptions, e as SelectState, f as createSelect } from './select-ClSy-J1f.js';
+export { C as CONTEXT_MENU_SEARCH_KEYS, a as ContextMenuAction, b as ContextMenuEntry, c as ContextMenuInstance, d as ContextMenuLabel, e as ContextMenuLevel, f as ContextMenuMoveKey, g as ContextMenuOptions, h as ContextMenuPoint, i as ContextMenuSeparator, j as ContextMenuState, k as createContextMenu, l as isAction } from './context-menu-D3FtTn7v.js';
+export { D as DEFAULT_SELECTION_SHORTCUTS, S as SelectionClickModifiers, a as SelectionCommand, b as SelectionCommandEvent, c as SelectionCommandName, d as SelectionInstance, e as SelectionOptions, f as SelectionShortcuts, g as SelectionState, h as createSelection } from './selection-B_pmzHpy.js';
+export { S as Shortcut, a as ShortcutEvent, b as ShortcutSpec, T as TYPEAHEAD_MS, c as TypeaheadState, d as TypeaheadStep, i as isApplePlatform, m as matchesShortcut, p as parseShortcut, s as shortcutList, e as shortcutText, f as shortcutTokens, t as typeaheadStep } from './keys-D2zJs1uB.js';
 
 /**
  * The icon shapes both renderers draw.

package/dist/index.js

@@ -1,11 +1,15 @@
 export { createInput } from './chunk-KJINGUQN.js';
+export { ensureZone, normalizeDate, parseDuration, relativeTimeAttributes, relativeTimeView } from './chunk-IXVMRVD4.js';
 export { estimatePasswordStrength, generatePassword } from './chunk-HC2ME5PU.js';
+export { CONTEXT_MENU_SEARCH_KEYS, createContextMenu, isAction } from './chunk-3BQVOOAM.js';
+export { DEFAULT_SELECTION_SHORTCUTS, createSelection } from './chunk-WSQC3PCC.js';
+export { createButton } from './chunk-MMQPZGSU.js';
 export { FLAG_CDN, FLAG_RATIO, configureFlags, flagAttributes, flagConfig, flagName, flagSrc, flagView, normalizeFlagCode, resetFlagConfig } from './chunk-LMZJBOZG.js';
+export { createNotifications } from './chunk-SNYUBXWQ.js';
 export { createMarquee } from './chunk-UOSSNUSC.js';
 export { SERVER_NETWORK_STATE, createNetworkMonitor } from './chunk-2QFTRNAZ.js';
-export { createNotifications } from './chunk-SNYUBXWQ.js';
-export { ensureZone, normalizeDate, parseDuration, relativeTimeAttributes, relativeTimeView } from './chunk-IXVMRVD4.js';
 export { INPUT_ICON_PATHS, iconMarkup } from './chunk-F25CGNQC.js';
+export { SELECT_SEARCH_KEYS, createSelect } from './chunk-NONGREXC.js';
+export { TYPEAHEAD_MS, isApplePlatform, matchesShortcut, parseShortcut, shortcutList, shortcutText, shortcutTokens, typeaheadStep } from './chunk-4VUHQFAT.js';
 export { createRecentStore, groupRows, isPaletteShortcut, moveActive, recentKey, shortcutLabel } from './chunk-DTWZDONY.js';
-export { createSearch, subsequenceMatcher } from './chunk-D5A2ZMAG.js';
-export { createButton } from './chunk-MMQPZGSU.js';
+export { createSearch, shortenQuery, subsequenceMatcher } from './chunk-4ZPMP47J.js';