@spectral_labs/ui 1.6.0 → 1.7.0

package/dist/components/command/__tests__/CommandInlineDirectTest.svelte

@@ -0,0 +1,29 @@
+<script lang="ts">
+  import CommandInput from '../components/command-input.svelte'
+  import CommandItem from '../components/command-item.svelte'
+  import CommandList from '../components/command-list.svelte'
+  import CommandRoot from '../components/command-root.svelte'
+
+  /**
+   * The same inline composition with NO `Command.Group`.
+   *
+   * The group and the item each gate rendering on their own predicate, and
+   * both read the registry. Reviewing #224 turned up two distinct failures
+   * behind one symptom, so the group must be removable from the picture for a
+   * test to say which mechanism it is exercising.
+   */
+  let open = $state(false)
+  let value = $state('')
+
+  export function setOpen(next: boolean) {
+    open = next
+  }
+</script>
+
+<CommandRoot mode="inline" bind:open bind:value>
+  <CommandInput class="probe-input" />
+  <CommandList>
+    <CommandItem value="copy" keywords={['duplicate']}>Copy</CommandItem>
+    <CommandItem value="paste">Paste</CommandItem>
+  </CommandList>
+</CommandRoot>

package/dist/components/command/__tests__/CommandInlineTest.svelte

@@ -0,0 +1,89 @@
+<script lang="ts">
+  import type { CommandMode } from '../command.svelte.js'
+  import CommandEmpty from '../components/command-empty.svelte'
+  import CommandGroup from '../components/command-group.svelte'
+  import CommandInput from '../components/command-input.svelte'
+  import CommandItem from '../components/command-item.svelte'
+  import CommandList from '../components/command-list.svelte'
+  import CommandRoot from '../components/command-root.svelte'
+
+  type Entry = { value: string; label: string; keywords?: string[] }
+
+  /**
+   * Harness for the `inline` composition: a field that outlives its results.
+   *
+   * The harness OWNS `open` and `entries` as local state and exposes accessors,
+   * rather than taking them as props a test would try to reassign — Svelte 5
+   * props are not writable through the object `mount()` returns. Owning them
+   * here is also closer to real use: `bind:open` lets the Root push a close
+   * back (Escape, outside pointer) and the test observes the same value the
+   * consumer would.
+   *
+   * `entries` is mutable so a test can change the COLLECTION between two
+   * openings — the case where a stale selection, a dead ARIA reference or a
+   * lost first arrow would actually show up.
+   */
+  const {
+    initialOpen = false,
+    initialEntries = [
+      { value: 'copy', label: 'Copy', keywords: ['duplicate'] },
+      { value: 'paste', label: 'Paste' },
+      { value: 'cut', label: 'Cut' },
+    ] as Entry[],
+    mode = 'inline' as CommandMode,
+    portalTo = undefined,
+    trapFocus = undefined,
+    onOpenChange = undefined,
+    onEscapeKeydown = undefined,
+    onSelect = undefined,
+    inputAttrs = undefined,
+  }: {
+    initialOpen?: boolean
+    initialEntries?: Entry[]
+    mode?: CommandMode
+    portalTo?: HTMLElement | string
+    trapFocus?: boolean
+    onOpenChange?: (open: boolean) => void
+    onEscapeKeydown?: (event: KeyboardEvent) => void
+    onSelect?: (value: string) => void
+    inputAttrs?: Record<string, unknown>
+  } = $props()
+
+  let open = $state(initialOpen)
+  let entries = $state(initialEntries)
+  let value = $state('')
+  let element = $state<HTMLInputElement | null>(null)
+
+  export function setOpen(next: boolean) {
+    open = next
+  }
+  export function getOpen() {
+    return open
+  }
+  export function setEntries(next: Entry[]) {
+    entries = next
+  }
+  export function getElement() {
+    return element
+  }
+</script>
+
+<CommandRoot bind:value bind:open {mode} {portalTo} {trapFocus} {onOpenChange} {onEscapeKeydown}>
+  <CommandInput
+    placeholder="Search..."
+    wrapperClass="probe-wrapper"
+    class="probe-input"
+    bind:element
+    {...inputAttrs ?? {}}
+  />
+  <CommandList>
+    <CommandEmpty>No results found.</CommandEmpty>
+    <CommandGroup heading="Actions">
+      {#each entries as entry (entry.value)}
+        <CommandItem value={entry.value} keywords={entry.keywords} {onSelect}>
+          {entry.label}
+        </CommandItem>
+      {/each}
+    </CommandGroup>
+  </CommandList>
+</CommandRoot>

package/dist/components/command/__tests__/command-inline.test.svelte.js

@@ -0,0 +1,392 @@
+import { flushSync, mount, unmount } from 'svelte';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { EscapeLayerState, resetEscapeLayerStack } from '../../../internal/escape-layer/index.js';
+import CommandInlineDirectTest from './CommandInlineDirectTest.svelte';
+import CommandInlineTest from './CommandInlineTest.svelte';
+/**
+ * `mode: 'inline'` — a persistent field with non-modal results.
+ *
+ * The contract these pins defend is not "the list is hidden": it is that a
+ * CLOSED palette is inert. It executes nothing, it claims no key, it holds no
+ * slot in the global layer stacks, and it names no option that is not on
+ * screen. `modal` is the default and must come through untouched.
+ */
+if (typeof globalThis.PointerEvent === 'undefined') {
+    // @ts-expect-error — minimal polyfill for testing
+    globalThis.PointerEvent = class PointerEvent extends MouseEvent {
+        constructor(type, init) {
+            super(type, init);
+        }
+    };
+}
+describe('command — inline mode', () => {
+    let target;
+    let instance;
+    function setup(props = {}) {
+        target = document.createElement('div');
+        document.body.appendChild(target);
+        instance = mount(CommandInlineTest, { target, props });
+        flushSync();
+        return target;
+    }
+    afterEach(() => {
+        if (instance)
+            unmount(instance);
+        instance = undefined;
+        target?.remove();
+        resetEscapeLayerStack();
+        document.body.innerHTML = '';
+    });
+    const input = () => target.querySelector('input.probe-input');
+    const options = () => [...target.querySelectorAll('[data-command-item]')];
+    const activeId = () => input().getAttribute('aria-activedescendant');
+    function press(key, init = {}) {
+        const event = new KeyboardEvent('keydown', { key, bubbles: true, cancelable: true, ...init });
+        input().dispatchEvent(event);
+        flushSync();
+        return event;
+    }
+    function type(text) {
+        const el = input();
+        el.value = text;
+        el.dispatchEvent(new Event('input', { bubbles: true }));
+        flushSync();
+    }
+    // --- The field outlives the results ------------------------------------
+    it('closed: the field is rendered and NO option is', () => {
+        setup({ initialOpen: false });
+        expect(input()).toBeTruthy();
+        expect(options()).toHaveLength(0);
+        expect(target.querySelector('[role="listbox"]')).toBeNull();
+    });
+    it('closed: aria-expanded is false, and the relations that would dangle are absent', () => {
+        setup({ initialOpen: false });
+        expect(input().getAttribute('aria-expanded')).toBe('false');
+        expect(input().getAttribute('aria-controls')).toBeNull();
+        expect(activeId()).toBeNull();
+    });
+    it('the SAME input element survives a close and a reopen — never a second field', () => {
+        setup({ initialOpen: true });
+        const first = input();
+        instance.setOpen(false);
+        flushSync();
+        expect(options()).toHaveLength(0);
+        const whileClosed = input();
+        instance.setOpen(true);
+        flushSync();
+        // Node identity, not a lookalike: a remounted field would lose focus,
+        // selection and any consumer `bind:element` reference.
+        expect(whileClosed).toBe(first);
+        expect(input()).toBe(first);
+    });
+    it('exposes the real input element through `bind:element`, with no internal selector', () => {
+        setup({ initialOpen: false });
+        expect(instance.getElement()).toBe(input());
+        instance.getElement().focus();
+        expect(document.activeElement).toBe(input());
+    });
+    // --- A closed palette claims nothing -----------------------------------
+    it('closed: Enter executes nothing and is NOT prevented — it belongs to the page', () => {
+        const onSelect = vi.fn();
+        setup({ initialOpen: false, onSelect });
+        const event = press('Enter');
+        expect(onSelect).not.toHaveBeenCalled();
+        expect(event.defaultPrevented).toBe(false);
+    });
+    it('closed: a third-party Escape layer mounted FIRST still receives the key', () => {
+        const onEscapeKeydown = vi.fn();
+        // Mounted BEFORE the palette, so it sits at the BOTTOM of the stack. The
+        // stack offers the keystroke to the topmost 'close' layer and stops there:
+        // a palette that illicitly kept its layer while closed would be above this
+        // one and would swallow the key. Mounted after, it would win either way
+        // and the test would pass on a broken implementation.
+        const other = new EscapeLayerState({ enabled: true, onEscapeKeydown });
+        other.mount();
+        setup({ initialOpen: false });
+        const event = press('Escape');
+        expect(onEscapeKeydown).toHaveBeenCalledTimes(1);
+        expect(event.defaultPrevented).toBe(false);
+        other.unmount();
+    });
+    it('open: the palette DOES take the key from a layer mounted before it — the test above discriminates', () => {
+        const onEscapeKeydown = vi.fn();
+        const other = new EscapeLayerState({ enabled: true, onEscapeKeydown });
+        other.mount();
+        setup({ initialOpen: true });
+        press('Escape');
+        // Same order, results open: the palette is topmost and answers, so the
+        // previous test really observes the layer being absent, not the ordering.
+        expect(onEscapeKeydown).not.toHaveBeenCalled();
+        expect(instance.getOpen()).toBe(false);
+        other.unmount();
+    });
+    it('closed: Home and End stay with the caret — native editing is preserved', () => {
+        setup({ initialOpen: false });
+        expect(press('Home').defaultPrevented).toBe(false);
+        expect(press('End').defaultPrevented).toBe(false);
+    });
+    it('closed: an arrow OPENS the results instead of moving an unseen selection', () => {
+        const onOpenChange = vi.fn();
+        setup({ initialOpen: false, onOpenChange });
+        const event = press('ArrowDown');
+        expect(event.defaultPrevented).toBe(true);
+        expect(onOpenChange).toHaveBeenCalledWith(true);
+        expect(instance.getOpen()).toBe(true);
+        flushSync();
+        expect(options().length).toBeGreaterThan(0);
+    });
+    // --- Open: the engine is the one that shipped ---------------------------
+    it('open: keyword filtering still decides — a term absent from the label finds the option', () => {
+        setup({ initialOpen: true });
+        type('duplicate');
+        const values = options().map((el) => el.dataset.value);
+        expect(values).toEqual(['copy']);
+    });
+    it('open: arrow then Enter activates the option exactly ONCE', () => {
+        const onSelect = vi.fn();
+        setup({ initialOpen: true, onSelect });
+        press('ArrowDown');
+        const selected = options().find((el) => el.dataset.selected === 'true');
+        press('Enter');
+        expect(onSelect).toHaveBeenCalledTimes(1);
+        expect(onSelect).toHaveBeenCalledWith(selected.dataset.value);
+    });
+    it('open: aria-activedescendant names the rendered option’s DOM id, never its value', () => {
+        setup({ initialOpen: true });
+        const selected = options().find((el) => el.dataset.selected === 'true');
+        expect(activeId()).toBe(selected.id);
+        expect(activeId()).not.toBe(selected.dataset.value);
+        // And it resolves to a node that is really in the document.
+        expect(document.getElementById(activeId())).toBe(selected);
+        expect(input().getAttribute('aria-controls')).toBe(target.querySelector('[role="listbox"]').id);
+    });
+    // --- The reference cannot outlive what it names -------------------------
+    it('after filtering, the reference follows the surviving option', () => {
+        setup({ initialOpen: true });
+        type('duplicate');
+        const selected = options().find((el) => el.dataset.selected === 'true');
+        expect(selected.dataset.value).toBe('copy');
+        expect(activeId()).toBe(selected.id);
+    });
+    it('when nothing matches, there is no active option and no reference', () => {
+        setup({ initialOpen: true });
+        type('zzzzz');
+        expect(options()).toHaveLength(0);
+        expect(activeId()).toBeNull();
+    });
+    it('removing the active option leaves no dead reference', () => {
+        setup({
+            initialOpen: true,
+            initialEntries: [
+                { value: 'copy', label: 'Copy' },
+                { value: 'paste', label: 'Paste' },
+            ],
+        });
+        expect(options().find((el) => el.dataset.selected === 'true').dataset.value).toBe('copy');
+        // The consumer drops the option that is currently active.
+        instance.setEntries([{ value: 'paste', label: 'Paste' }]);
+        flushSync();
+        const id = activeId();
+        expect(id).not.toBeNull();
+        const named = document.getElementById(id);
+        expect(named).not.toBeNull();
+        expect(named.dataset.value).toBe('paste');
+    });
+    it('reopening after the options changed: no stale selection, no dead reference, no lost first arrow', () => {
+        const onSelect = vi.fn();
+        setup({
+            initialOpen: true,
+            onSelect,
+            initialEntries: [
+                { value: 'copy', label: 'Copy' },
+                { value: 'paste', label: 'Paste' },
+            ],
+        });
+        // Move the selection away from the first option, then close.
+        press('ArrowDown');
+        expect(options().find((el) => el.dataset.selected === 'true').dataset.value).toBe('paste');
+        instance.setOpen(false);
+        flushSync();
+        expect(activeId()).toBeNull();
+        // A completely different collection comes back.
+        instance.setEntries([
+            { value: 'rename', label: 'Rename' },
+            { value: 'delete', label: 'Delete' },
+        ]);
+        instance.setOpen(true);
+        flushSync();
+        const selected = options().find((el) => el.dataset.selected === 'true');
+        // Not the stale `paste`, which no longer exists.
+        expect(selected.dataset.value).toBe('rename');
+        expect(activeId()).toBe(selected.id);
+        // The first arrow MOVES; it is not spent recovering from a stale value.
+        press('ArrowDown');
+        expect(options().find((el) => el.dataset.selected === 'true').dataset.value).toBe('delete');
+        press('Enter');
+        expect(onSelect).toHaveBeenCalledTimes(1);
+        expect(onSelect).toHaveBeenCalledWith('delete');
+    });
+    // --- A retained query must survive a remount (review of #224, [P1]) -----
+    /**
+     * One symptom — zero options after a close and a reopen with the query still
+     * in the field — hiding TWO mechanisms, so each gets its own pin.
+     *
+     *  · `Command.Group` gated its children on `hasVisibleItems()`, a predicate
+     *    over the very registry those children fill. Empty registry + retained
+     *    query ⇒ children never mount ⇒ registry stays empty. A deadlock.
+     *  · An item's `isVisible` reads `getScore()` from a plain Map during
+     *    RENDER, while `registerItem` writes that score from an `$effect`, i.e.
+     *    afterwards. Nothing woke the derived, so a matching item stayed hidden.
+     *
+     * Both make `aria-activedescendant` name a node that is not in the document,
+     * which is why every pin here resolves the id rather than trusting it.
+     */
+    function activeElement() {
+        const id = activeId();
+        return id === null ? null : document.getElementById(id);
+    }
+    it('a query kept across a close and a reopen still renders its match, named and actionable', () => {
+        const onSelect = vi.fn();
+        setup({ initialOpen: true, onSelect });
+        type('duplicate');
+        expect(options().map((el) => el.dataset.value)).toEqual(['copy']);
+        instance.setOpen(false);
+        flushSync();
+        expect(options()).toHaveLength(0);
+        instance.setOpen(true);
+        flushSync();
+        expect(options().map((el) => el.dataset.value)).toEqual(['copy']);
+        // The reference resolves to a node that is really in the document.
+        expect(activeElement()).not.toBeNull();
+        expect(activeElement()).toBe(options()[0]);
+        press('Enter');
+        expect(onSelect).toHaveBeenCalledTimes(1);
+        expect(onSelect).toHaveBeenCalledWith('copy');
+    });
+    it('a query typed while CLOSED renders its match when an arrow opens the list', () => {
+        setup({ initialOpen: false });
+        type('duplicate');
+        expect(options()).toHaveLength(0);
+        press('ArrowDown');
+        expect(options().map((el) => el.dataset.value)).toEqual(['copy']);
+        expect(activeElement()).toBe(options()[0]);
+    });
+    it('same, with NO Command.Group: the item mechanism alone is enough to break it', () => {
+        target = document.createElement('div');
+        document.body.appendChild(target);
+        instance = mount(CommandInlineDirectTest, { target });
+        flushSync();
+        type('duplicate');
+        press('ArrowDown');
+        expect(options().map((el) => el.dataset.value)).toEqual(['copy']);
+        expect(activeElement()).not.toBeNull();
+        expect(activeElement()).toBe(options()[0]);
+    });
+    // --- Event composition --------------------------------------------------
+    it('a consumer onkeydown runs first and its preventDefault cancels the local handling', () => {
+        const onOpenChange = vi.fn();
+        setup({
+            initialOpen: false,
+            onOpenChange,
+            inputAttrs: { onkeydown: (e) => e.preventDefault() },
+        });
+        press('ArrowDown');
+        expect(onOpenChange).not.toHaveBeenCalled();
+        expect(instance.getOpen()).toBe(false);
+    });
+    it('a consumer onkeydown cannot retract a close already performed in the capture phase', () => {
+        const onEscapeKeydown = vi.fn();
+        setup({
+            initialOpen: true,
+            onEscapeKeydown,
+            inputAttrs: { onkeydown: (e) => e.preventDefault() },
+        });
+        press('Escape');
+        // The layer listens on `document` in capture — it read `defaultPrevented`
+        // before the input's handler ever ran. `onEscapeKeydown` is the hook.
+        expect(onEscapeKeydown).toHaveBeenCalledTimes(1);
+        expect(instance.getOpen()).toBe(false);
+    });
+    // --- Anchorable, and no focus trap --------------------------------------
+    it('renders IN PLACE with the inline chrome released, so results can be anchored', () => {
+        setup({ initialOpen: true });
+        const root = target.querySelector('.sp-command');
+        // In place — not portalled to document.body, which would break both the
+        // consumer's scoped CSS and any anchoring to the field.
+        expect(root.parentElement).not.toBe(document.body);
+        expect(target.contains(root)).toBe(true);
+        expect(root.dataset.mode).toBe('inline');
+        // The field and the results share one owner, which is what lets a consumer
+        // anchor the second to the first.
+        const field = root.querySelector('.sp-command-input-wrapper');
+        const list = root.querySelector('[role="listbox"]');
+        expect(field.parentElement).toBe(root);
+        expect(list.parentElement).toBe(root);
+        // Whether the released `overflow` really keeps the list unclipped is a
+        // LAYOUT fact, and this environment has no CSS at all — vite does not load
+        // the components' stylesheets into jsdom. It is proven in a real Chromium
+        // by `tests/e2e/command-inline.spec.ts`, on the docs page's live demo.
+    });
+    it('does not trap focus: an outside control keeps it', () => {
+        setup({ initialOpen: true });
+        const outside = document.createElement('button');
+        document.body.appendChild(outside);
+        outside.focus();
+        flushSync();
+        expect(document.activeElement).toBe(outside);
+        outside.remove();
+    });
+    it('the consumer names the field; the component keeps its structure', () => {
+        setup({
+            initialOpen: true,
+            inputAttrs: {
+                'aria-label': 'Site search',
+                'aria-describedby': 'hint-id',
+                title: 'Search',
+                'data-testid': 'field',
+                // Refused by the type; spread anyway to prove the markup order wins.
+                role: 'textbox',
+                id: 'consumer-id',
+                'aria-expanded': 'false',
+                'aria-activedescendant': 'nope',
+            },
+        });
+        const el = input();
+        // The consumer's naming and description reach the real combobox…
+        expect(el.getAttribute('aria-label')).toBe('Site search');
+        expect(el.getAttribute('aria-describedby')).toBe('hint-id');
+        expect(el.getAttribute('title')).toBe('Search');
+        expect(el.getAttribute('data-testid')).toBe('field');
+        // …while the structure stays the component's, whatever is spread.
+        expect(el.getAttribute('role')).toBe('combobox');
+        expect(el.id).not.toBe('consumer-id');
+        expect(el.getAttribute('aria-expanded')).toBe('true');
+        expect(el.getAttribute('aria-activedescendant')).not.toBe('nope');
+        expect(el.getAttribute('aria-activedescendant')).toBe(options().find((o) => o.dataset.selected === 'true').id);
+    });
+    it('exposes the wrapper through `wrapperClass` while `class` stays on the input', () => {
+        setup({ initialOpen: false });
+        const wrapper = target.querySelector('.sp-command-input-wrapper');
+        expect(wrapper.classList.contains('probe-wrapper')).toBe(true);
+        expect(input().classList.contains('probe-input')).toBe(true);
+        expect(input().classList.contains('probe-wrapper')).toBe(false);
+    });
+    // --- The default mode is untouched --------------------------------------
+    it('modal stays the default: closing unmounts the field itself', () => {
+        // `portalTo` keeps the modal content inside `target` for querying — the
+        // modal default is `document.body`, which is itself part of the contract.
+        target = document.createElement('div');
+        document.body.appendChild(target);
+        instance = mount(CommandInlineTest, {
+            target,
+            props: { mode: 'modal', initialOpen: true, portalTo: target },
+        });
+        flushSync();
+        expect(input()).toBeTruthy();
+        expect(input().getAttribute('aria-expanded')).toBe('true');
+        instance.setOpen(false);
+        flushSync();
+        expect(target.querySelector('input')).toBeNull();
+        expect(target.querySelector('.sp-command')).toBeNull();
+    });
+});

package/dist/components/command/command.svelte.d.ts

@@ -4,6 +4,14 @@
  * Manages search filtering, item scoring, keyboard navigation,
  * and selection for a command palette interface.
  */
+/**
+ * `'modal'` — the shipped behaviour: the Root exists only while open, and
+ * closing unmounts everything, layers included.
+ * `'inline'` — the Root and its field stay mounted; `open` then governs only
+ * whether the RESULTS are rendered, and the Escape / outside-pointer layers
+ * follow the results, never the field.
+ */
+export type CommandMode = 'modal' | 'inline';
 export interface CommandItem {
     id: string;
     value: string;
@@ -18,6 +26,25 @@ export interface CommandState {
     listId: string;
     shouldFilter: boolean;
     loop: boolean;
+    /** Composition mode of the owning Root. */
+    mode: CommandMode;
+    /** Whether the Root currently considers the palette open. */
+    open: boolean;
+    /** Whether a `Command.List` is actually rendered right now. */
+    listMounted: boolean;
+    /** Called by `Command.List` to report its own mount/unmount. */
+    setListMounted: (mounted: boolean) => void;
+    /**
+     * DOM id of the option that is BOTH active and rendered, or `null`.
+     *
+     * Resolved against the live registry — never from the stored selection
+     * alone — so it cannot outlive the option it names: filtering it out,
+     * unmounting the list, or removing the option all make it `null` on the
+     * spot. This is what `aria-activedescendant` reads.
+     */
+    getActiveOptionId: () => string | null;
+    /** Asks the Root to open. No-op when it is already open. */
+    requestOpen: () => void;
     setSearch: (query: string) => void;
     getScore: (value: string) => number;
     filter: (value: string, search: string, keywords?: string[]) => number;
@@ -47,7 +74,10 @@ export declare function createCommandState(options: {
     filter: (value: string, search: string, keywords?: string[]) => number;
     shouldFilter: boolean;
     loop: boolean;
+    mode: CommandMode;
+    open: boolean;
     onSearchChange?: (search: string) => void;
+    onRequestOpen?: () => void;
 }): CommandState;
 export declare function setCommandContext(state: CommandState): void;
 export declare function getCommandContext(): CommandState;

package/dist/components/command/command.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command.svelte.d.ts","sourceRoot":"","sources":["../../../src/lib/components/command/command.svelte.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,EAAE,MAAM,CAAA;IACrB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,OAAO,CAAA;IACrB,IAAI,EAAE,OAAO,CAAA;IACb,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IACnC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,CAAA;IACtE,YAAY,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAA;IACzC,cAAc,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IACpC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC/B,gBAAgB,EAAE,MAAM,MAAM,CAAA;IAC9B,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,KAAK,IAAI,CAAA;IACtE,aAAa,EAAE,MAAM,IAAI,CAAA;IACzB,QAAQ,EAAE,MAAM,WAAW,EAAE,CAAA;IAC7B,eAAe,EAAE,MAAM,WAAW,EAAE,CAAA;IACpC,eAAe,EAAE,MAAM,OAAO,CAAA;CAC/B;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAYxF;AA0CD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAC1C,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,CAAA;IACtE,YAAY,EAAE,OAAO,CAAA;IACrB,IAAI,EAAE,OAAO,CAAA;IACb,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;CAC1C,GAAG,YAAY,CA+Hf;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAE3D;AAED,wBAAgB,iBAAiB,IAAI,YAAY,CAEhD"}
+{"version":3,"file":"command.svelte.d.ts","sourceRoot":"","sources":["../../../src/lib/components/command/command.svelte.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,QAAQ,CAAA;AAE5C,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,EAAE,MAAM,CAAA;IACrB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,OAAO,CAAA;IACrB,IAAI,EAAE,OAAO,CAAA;IACb,2CAA2C;IAC3C,IAAI,EAAE,WAAW,CAAA;IACjB,6DAA6D;IAC7D,IAAI,EAAE,OAAO,CAAA;IACb,+DAA+D;IAC/D,WAAW,EAAE,OAAO,CAAA;IACpB,gEAAgE;IAChE,cAAc,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IAC1C;;;;;;;OAOG;IACH,iBAAiB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;IACtC,4DAA4D;IAC5D,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IACnC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,CAAA;IACtE,YAAY,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAA;IACzC,cAAc,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IACpC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC/B,gBAAgB,EAAE,MAAM,MAAM,CAAA;IAC9B,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,KAAK,IAAI,CAAA;IACtE,aAAa,EAAE,MAAM,IAAI,CAAA;IACzB,QAAQ,EAAE,MAAM,WAAW,EAAE,CAAA;IAC7B,eAAe,EAAE,MAAM,WAAW,EAAE,CAAA;IACpC,eAAe,EAAE,MAAM,OAAO,CAAA;CAC/B;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAYxF;AA0CD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAC1C,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,CAAA;IACtE,YAAY,EAAE,OAAO,CAAA;IACrB,IAAI,EAAE,OAAO,CAAA;IACb,IAAI,EAAE,WAAW,CAAA;IACjB,IAAI,EAAE,OAAO,CAAA;IACb,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IACzC,aAAa,CAAC,EAAE,MAAM,IAAI,CAAA;CAC3B,GAAG,YAAY,CA6Mf;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAE3D;AAED,wBAAgB,iBAAiB,IAAI,YAAY,CAEhD"}