@opentui/keymap 0.2.1 → 0.2.3

package/src/services/state.d.ts

@@ -1,115 +1,70 @@
-import type { ActiveKey, BindingExpander, BindingFieldCompiler, BindingParser, BindingTransformer, CommandFieldCompiler, CommandResolver, EventData, KeyDisambiguationResolver, EventMatchResolver, KeyInputContext, KeySequencePart, KeymapEvent, LayerAnalyzer, LayerFieldCompiler, PendingSequenceState, RawInputContext, RegisteredCommand, RegisteredLayer, ResolvedBindingCommand, RuntimeMatchable } from "../types.js";
-import { OrderedRegistry, PriorityRegistry } from "../lib/registry.js";
-export interface CoreState {
-    order: number;
-}
-export interface EnvironmentState<TTarget extends object, TEvent extends KeymapEvent> {
-    tokens: Map<string, import("../types.js").ResolvedKeyToken>;
-    layerFields: Map<string, LayerFieldCompiler>;
-    bindingExpanders: OrderedRegistry<BindingExpander>;
-    bindingParsers: OrderedRegistry<BindingParser>;
-    bindingTransformers: OrderedRegistry<BindingTransformer<TTarget, TEvent>>;
-    bindingFields: Map<string, BindingFieldCompiler>;
-    commandFields: Map<string, CommandFieldCompiler>;
-}
-export interface DispatchState<TTarget extends object, TEvent extends KeymapEvent> {
-    eventMatchResolvers: OrderedRegistry<EventMatchResolver<TEvent>>;
-    disambiguationResolvers: OrderedRegistry<KeyDisambiguationResolver<TTarget, TEvent>>;
-    keyHooks: PriorityRegistry<(ctx: KeyInputContext<TEvent>) => void, {
-        priority: number;
-        release: boolean;
-    }>;
-    rawHooks: PriorityRegistry<(ctx: RawInputContext) => void, {
-        priority: number;
-    }>;
-}
-export interface LayersState<TTarget extends object, TEvent extends KeymapEvent> {
-    layers: Set<RegisteredLayer<TTarget, TEvent>>;
-    sortedLayers: RegisteredLayer<TTarget, TEvent>[];
-    activeLayersVersion: number;
-    activeLayersCacheVersion: number;
-    activeLayersCacheFocused: TTarget | null | undefined;
-    activeLayersCache: readonly RegisteredLayer<TTarget, TEvent>[];
-    layersWithConditions: number;
-    layersWithCommands: number;
-    layerAnalyzers: OrderedRegistry<LayerAnalyzer<TTarget, TEvent>>;
-}
+import type { Attributes, BindingExpander, BindingFieldCompiler, LayerBindingsTransformer, BindingParser, BindingTransformer, Command, CommandFieldCompiler, CommandTransformer, CommandResolver, EventData, KeyDisambiguationResolver, EventMatchResolver, KeyAfterInputContext, KeyInputContext, KeymapEvent, LayerFieldCompiler, PendingSequenceState, RawInputContext, ResolvedSequencePattern, CommandState, RegisteredLayer } from "../types.js";
+import { type RuntimeOrderedRegistry, type RuntimePriorityRegistry } from "../lib/runtime-utils.js";
 export interface LayerCommandEntry<TTarget extends object, TEvent extends KeymapEvent> {
     layer: RegisteredLayer<TTarget, TEvent>;
-    command: RegisteredCommand<TTarget, TEvent>;
+    commandState: CommandState<TTarget, TEvent>;
 }
 export interface ResolvedCommandEntry<TTarget extends object, TEvent extends KeymapEvent> {
     target?: TTarget;
-    resolved: ResolvedBindingCommand<TTarget, TEvent>;
-}
-export interface CommandChainCacheState<TTarget extends object, TEvent extends KeymapEvent> {
-    resolvedWithoutRecordChains: Map<string, readonly ResolvedCommandEntry<TTarget, TEvent>[]>;
-    resolvedWithRecordChains: Map<string, readonly ResolvedCommandEntry<TTarget, TEvent>[]>;
-    fallbackWithoutRecord: Map<string, ResolvedBindingCommand<TTarget, TEvent> | null>;
-    fallbackWithRecord: Map<string, ResolvedBindingCommand<TTarget, TEvent> | null>;
-    fallbackWithoutRecordErrors: Set<string>;
-    fallbackWithRecordErrors: Set<string>;
+    command: Command<TTarget, TEvent>;
+    attrs?: Readonly<Attributes>;
+    input?: string;
+    payload?: unknown;
 }
-export interface ActiveCommandView<TTarget extends object, TEvent extends KeymapEvent> extends CommandChainCacheState<TTarget, TEvent> {
-    cacheable: boolean;
+export interface ActiveCommandView<TTarget extends object, TEvent extends KeymapEvent> {
+    layers: readonly RegisteredLayer<TTarget, TEvent>[];
     entries: readonly LayerCommandEntry<TTarget, TEvent>[];
     reachable: readonly LayerCommandEntry<TTarget, TEvent>[];
     reachableByName: ReadonlyMap<string, LayerCommandEntry<TTarget, TEvent>>;
     chainsByName: ReadonlyMap<string, readonly LayerCommandEntry<TTarget, TEvent>[]>;
 }
-export interface RegisteredCommandView<TTarget extends object, TEvent extends KeymapEvent> extends CommandChainCacheState<TTarget, TEvent> {
+export interface CommandView<TTarget extends object, TEvent extends KeymapEvent> {
     entries: readonly LayerCommandEntry<TTarget, TEvent>[];
     chainsByName: ReadonlyMap<string, readonly LayerCommandEntry<TTarget, TEvent>[]>;
 }
-export interface CommandsState<TTarget extends object, TEvent extends KeymapEvent> {
-    commandMetadataVersion: number;
-    registeredNames: Map<string, number>;
-    commandResolvers: OrderedRegistry<CommandResolver<TTarget, TEvent>>;
-    activeCommandViewVersion: number;
-    activeCommandView?: ActiveCommandView<TTarget, TEvent>;
-    registeredCommandViewVersion: number;
-    registeredCommandView?: RegisteredCommandView<TTarget, TEvent>;
-    registeredCommandEntriesCacheVersion: number;
-    registeredCommandEntriesCache: readonly LayerCommandEntry<TTarget, TEvent>[];
-}
-export interface ProjectionState<TTarget extends object, TEvent extends KeymapEvent> {
-    pendingSequence: PendingSequenceState<TTarget, TEvent> | null;
-    pendingSequenceCacheVersion: number;
-    pendingSequenceCache: readonly KeySequencePart[];
-    activeKeysPlainCacheVersion: number;
-    activeKeysPlainCache: readonly ActiveKey<TTarget, TEvent>[];
-    activeKeysBindingsCacheVersion: number;
-    activeKeysBindingsCache: readonly ActiveKey<TTarget, TEvent>[];
-    activeKeysMetadataCacheVersion: number;
-    activeKeysMetadataCache: readonly ActiveKey<TTarget, TEvent>[];
-    activeKeysBindingsAndMetadataCacheVersion: number;
-    activeKeysBindingsAndMetadataCache: readonly ActiveKey<TTarget, TEvent>[];
-}
-export interface ConditionsState {
-    runtimeKeyDependents: Map<string, Set<RuntimeMatchable>>;
-}
-export interface RuntimeState {
+export interface State<TTarget extends object, TEvent extends KeymapEvent> {
+    order: number;
+    tokens: Map<string, import("../types.js").ResolvedKeyToken>;
+    patterns: Map<string, ResolvedSequencePattern<TEvent>>;
+    layerFields: Map<string, LayerFieldCompiler>;
+    layerBindingsTransformers: RuntimeOrderedRegistry<LayerBindingsTransformer<TTarget, TEvent>>;
+    bindingExpanders: RuntimeOrderedRegistry<BindingExpander>;
+    bindingParsers: RuntimeOrderedRegistry<BindingParser>;
+    bindingTransformers: RuntimeOrderedRegistry<BindingTransformer<TTarget, TEvent>>;
+    bindingFields: Map<string, BindingFieldCompiler>;
+    commandTransformers: RuntimeOrderedRegistry<CommandTransformer<TTarget, TEvent>>;
+    commandFields: Map<string, CommandFieldCompiler>;
+    eventMatchResolvers: RuntimeOrderedRegistry<EventMatchResolver<TEvent>>;
+    disambiguationResolvers: RuntimeOrderedRegistry<KeyDisambiguationResolver<TTarget, TEvent>>;
+    keyHooks: RuntimePriorityRegistry<(ctx: KeyInputContext<TEvent>) => void, {
+        priority: number;
+        release: boolean;
+    }>;
+    keyAfterHooks: RuntimePriorityRegistry<(ctx: KeyAfterInputContext<TTarget, TEvent>) => void, {
+        priority: number;
+        release: boolean;
+    }>;
+    rawHooks: RuntimePriorityRegistry<(ctx: RawInputContext) => void, {
+        priority: number;
+    }>;
+    layers: Set<RegisteredLayer<TTarget, TEvent>>;
+    sortedLayers: RegisteredLayer<TTarget, TEvent>[];
+    activeLayersCacheVersion: number;
+    activeLayersCacheFocused: TTarget | null | undefined;
+    activeLayersCache: RegisteredLayer<TTarget, TEvent>[];
+    activeKeyCacheBlockers: number;
+    activeCommandViewCacheBlockers: number;
+    commandResolvers: RuntimeOrderedRegistry<CommandResolver<TTarget, TEvent>>;
+    pending: PendingSequenceState<TTarget, TEvent> | null;
     data: EventData;
     dataVersion: number;
     readonlyDataVersion: number;
     readonlyData: Readonly<EventData>;
-}
-export interface NotifyState {
-    derivedStateVersion: number;
+    cacheVersion: number;
+    derivedVersion: number;
     stateChangeDepth: number;
     stateChangePending: boolean;
     flushingStateChange: boolean;
     usedWarningKeys: Set<string>;
 }
-export interface State<TTarget extends object, TEvent extends KeymapEvent> {
-    core: CoreState;
-    environment: EnvironmentState<TTarget, TEvent>;
-    dispatch: DispatchState<TTarget, TEvent>;
-    layers: LayersState<TTarget, TEvent>;
-    commands: CommandsState<TTarget, TEvent>;
-    projection: ProjectionState<TTarget, TEvent>;
-    conditions: ConditionsState;
-    runtime: RuntimeState;
-    notify: NotifyState;
-}
 export declare function createKeymapState<TTarget extends object, TEvent extends KeymapEvent>(): State<TTarget, TEvent>;

package/src/solid/index.d.ts

@@ -1,5 +1,5 @@
 import type { KeyEvent, Renderable } from "@opentui/core";
-import { type Keymap, type LayerFields, type ReactiveMatcher } from "../index.js";
+import { type Keymap, type Layer, type ReactiveMatcher, type TargetMode } from "../index.js";
 import { type Accessor, type JSX } from "solid-js";
 type OpenTuiKeymap = Keymap<Renderable, KeyEvent>;
 export interface KeymapProviderProps {
@@ -8,31 +8,17 @@ export interface KeymapProviderProps {
 }
 export declare function KeymapProvider(props: KeymapProviderProps): JSX.Element;
 export type UseBindingsTarget<TRenderable extends Renderable = Renderable> = () => TRenderable | null | undefined;
-type UseBindingsLayerBase = LayerFields<Renderable, KeyEvent>;
-export interface UseGlobalBindingsLayer extends UseBindingsLayerBase {
-    target?: undefined;
+export interface UseBindingsLayer<TRenderable extends Renderable = Renderable> extends Omit<Layer<Renderable, KeyEvent>, "target" | "targetMode"> {
+    target?: UseBindingsTarget<TRenderable>;
+    targetMode?: TargetMode;
 }
-export interface UseFocusBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
-    targetMode: "focus";
-    target: UseBindingsTarget<TRenderable>;
-}
-export interface UseFocusWithinBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
-    targetMode?: "focus-within";
-    target: UseBindingsTarget<TRenderable>;
-}
-export interface UseInferredFocusWithinBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
-    target: UseBindingsTarget<TRenderable>;
-}
-export type UseTargetBindingsLayer<TRenderable extends Renderable = Renderable> = UseFocusBindingsLayer<TRenderable> | UseFocusWithinBindingsLayer<TRenderable> | UseInferredFocusWithinBindingsLayer<TRenderable>;
-export type UseBindingsLayer<TRenderable extends Renderable = Renderable> = UseGlobalBindingsLayer | UseTargetBindingsLayer<TRenderable>;
 export declare const useKeymap: () => OpenTuiKeymap;
 /**
  * Reactively derives any view from the current keymap by re-running `selector`
  * on each batched keymap state change.
  */
 export declare const useKeymapSelector: <T>(selector: (keymap: OpenTuiKeymap) => T) => Accessor<T>;
-export declare function useBindings<TRenderable extends Renderable = Renderable>(createLayer: () => UseGlobalBindingsLayer): void;
-export declare function useBindings<TRenderable extends Renderable = Renderable>(createLayer: () => UseTargetBindingsLayer<TRenderable>): void;
+export declare function useBindings<TRenderable extends Renderable = Renderable>(createLayer: () => UseBindingsLayer<TRenderable>): void;
 /**
  * Adapts a Solid accessor to `ReactiveMatcher`. The subscription
  * lives in a disposable reactive root so unregistering the layer tears it

package/{solid → src/solid}/index.js

@@ -115,3 +115,6 @@ export {
   reactiveMatcherFromSignal,
   KeymapProvider
 };
+
+//# debugId=A624A2E448C2557164756E2164756E21
+//# sourceMappingURL=index.js.map

package/src/solid/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/solid/index.ts"],
+  "sourcesContent": [
+    "import type { KeyEvent, Renderable } from \"@opentui/core\"\nimport { type Keymap, type Layer, type ReactiveMatcher, type TargetMode } from \"../index.js\"\nimport {\n  createComponent,\n  createContext,\n  createEffect,\n  createMemo,\n  createRoot,\n  createSignal,\n  on,\n  onCleanup,\n  onMount,\n  useContext,\n  type Accessor,\n  type JSX,\n} from \"solid-js\"\n\ntype OpenTuiKeymap = Keymap<Renderable, KeyEvent>\n\nconst KeymapContext = createContext<OpenTuiKeymap>()\n\nexport interface KeymapProviderProps {\n  keymap: OpenTuiKeymap\n  children: JSX.Element\n}\n\nexport function KeymapProvider(props: KeymapProviderProps): JSX.Element {\n  return createComponent(KeymapContext.Provider, {\n    get value() {\n      return props.keymap\n    },\n    get children() {\n      return props.children\n    },\n  })\n}\n\nexport type UseBindingsTarget<TRenderable extends Renderable = Renderable> = () => TRenderable | null | undefined\n\nexport interface UseBindingsLayer<TRenderable extends Renderable = Renderable> extends Omit<\n  Layer<Renderable, KeyEvent>,\n  \"target\" | \"targetMode\"\n> {\n  target?: UseBindingsTarget<TRenderable>\n  targetMode?: TargetMode\n}\n\nfunction resolveBindingsTarget(target: UseBindingsTarget | undefined): Renderable | undefined {\n  return target?.() ?? undefined\n}\n\nexport const useKeymap = (): OpenTuiKeymap => {\n  const keymap = useContext(KeymapContext)\n\n  if (!keymap) {\n    throw new Error(\"Keymap not found. Wrap the tree in <KeymapProvider>.\")\n  }\n\n  return keymap\n}\n\nfunction useKeymapStateVersion(keymap: OpenTuiKeymap): Accessor<number> {\n  const [version, setVersion] = createSignal(0)\n  let dispose: (() => void) | undefined\n\n  onMount(() => {\n    dispose = keymap.on(\"state\", () => {\n      setVersion((value) => value + 1)\n    })\n\n    setVersion((value) => value + 1)\n  })\n\n  onCleanup(() => {\n    dispose?.()\n  })\n\n  return version\n}\n\n/**\n * Reactively derives any view from the current keymap by re-running `selector`\n * on each batched keymap state change.\n */\nexport const useKeymapSelector = <T>(selector: (keymap: OpenTuiKeymap) => T): Accessor<T> => {\n  const keymap = useKeymap()\n  const version = useKeymapStateVersion(keymap)\n\n  return createMemo((previous) => {\n    version()\n    try {\n      return selector(keymap)\n    } catch (error) {\n      if (\n        previous !== undefined &&\n        error instanceof Error &&\n        error.message === \"Cannot use a keymap after its host was destroyed\"\n      ) {\n        return previous\n      }\n\n      throw error\n    }\n  })\n}\n\nexport function useBindings<TRenderable extends Renderable = Renderable>(\n  createLayer: () => UseBindingsLayer<TRenderable>,\n): void {\n  const keymap = useKeymap()\n\n  createEffect(() => {\n    const layer = createLayer()\n    const hasExplicitTarget = layer.target !== undefined\n    const explicitTarget = resolveBindingsTarget(layer.target)\n    const nextTargetMode: TargetMode | undefined = layer.targetMode ?? (hasExplicitTarget ? \"focus-within\" : undefined)\n\n    const { target: _target, targetMode: _targetMode, ...baseLayer } = layer\n    if (!nextTargetMode) {\n      const dispose = keymap.registerLayer({\n        ...baseLayer,\n      })\n\n      onCleanup(() => {\n        dispose()\n      })\n\n      return\n    }\n\n    if (!hasExplicitTarget) {\n      throw new Error(\"useBindings local bindings need a target accessor\")\n    }\n\n    if (!explicitTarget) {\n      return\n    }\n\n    const dispose = keymap.registerLayer({\n      ...baseLayer,\n      target: explicitTarget,\n      targetMode: nextTargetMode,\n    })\n\n    onCleanup(() => {\n      dispose()\n    })\n  })\n}\n\n/**\n * Adapts a Solid accessor to `ReactiveMatcher`. The subscription\n * lives in a disposable reactive root so unregistering the layer tears it\n * down. Pass `predicate` when the accessor value is not already boolean.\n */\nexport function reactiveMatcherFromSignal<T>(\n  accessor: Accessor<T>,\n  predicate?: (value: T) => boolean,\n): ReactiveMatcher {\n  return {\n    get() {\n      return predicate ? predicate(accessor()) : Boolean(accessor())\n    },\n    subscribe(onChange) {\n      return createRoot((dispose) => {\n        createEffect(on(accessor, () => onChange(), { defer: true }))\n        return dispose\n      })\n    },\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "A624A2E448C2557164756E2164756E21",
+  "names": []
+}

package/src/testing/index.d.ts

@@ -0,0 +1,90 @@
+import { Keymap } from "@opentui/keymap";
+import type { ErrorEvent, HostMetadata, KeymapEvent, KeymapHost, WarningEvent } from "@opentui/keymap";
+export type TestKeyModifierOptions = Partial<Pick<KeymapEvent, "ctrl" | "shift" | "meta" | "super" | "hyper">>;
+export type TestHostMetadataOptions = Partial<Omit<HostMetadata, "modifiers">> & {
+    modifiers?: Partial<HostMetadata["modifiers"]>;
+};
+export interface CreateTestKeymapHostOptions {
+    metadata?: HostMetadata | TestHostMetadataOptions;
+}
+export interface CreateTestKeymapOptions extends CreateTestKeymapHostOptions {
+    defaultKeys?: boolean;
+}
+export interface TestDiagnosticCapture {
+    readonly warnings: readonly string[];
+    readonly errors: readonly string[];
+    readonly warningEvents: readonly WarningEvent[];
+    readonly errorEvents: readonly ErrorEvent[];
+    takeWarnings(): {
+        warnings: string[];
+        warningEvents: WarningEvent[];
+    };
+    takeErrors(): {
+        errors: string[];
+        errorEvents: ErrorEvent[];
+    };
+    clear(): void;
+    dispose(): void;
+}
+export interface TestKeymapHarness {
+    keymap: Keymap<TestKeymapTarget, TestKeymapEvent>;
+    host: TestKeymapHost;
+    root: TestKeymapTarget;
+    diagnostics: TestDiagnosticCapture;
+    cleanup(): void;
+}
+export declare const DEFAULT_TEST_HOST_METADATA: HostMetadata;
+export declare class TestKeymapTarget {
+    readonly id: string;
+    parent: TestKeymapTarget | null;
+    isDestroyed: boolean;
+    constructor(id: string);
+    append(child: TestKeymapTarget): TestKeymapTarget;
+}
+export declare class TestKeymapEvent implements KeymapEvent {
+    readonly name: string;
+    readonly ctrl: boolean;
+    readonly shift: boolean;
+    readonly meta: boolean;
+    readonly super: boolean;
+    readonly hyper?: boolean;
+    propagationStopped: boolean;
+    defaultPrevented: boolean;
+    constructor(name: string, modifiers?: TestKeyModifierOptions);
+    preventDefault(): void;
+    stopPropagation(): void;
+}
+export declare class TestKeymapHost implements KeymapHost<TestKeymapTarget, TestKeymapEvent> {
+    readonly metadata: HostMetadata;
+    readonly rootTarget: TestKeymapTarget;
+    isDestroyed: boolean;
+    private focusedTarget;
+    private readonly keyPressListeners;
+    private readonly keyReleaseListeners;
+    private readonly focusListeners;
+    private readonly destroyListeners;
+    private readonly rawListeners;
+    private readonly targetDestroyListeners;
+    constructor(options?: CreateTestKeymapHostOptions);
+    createTarget(id: string): TestKeymapTarget;
+    getFocusedTarget(): TestKeymapTarget | null;
+    getParentTarget(target: TestKeymapTarget): TestKeymapTarget | null;
+    isTargetDestroyed(target: TestKeymapTarget): boolean;
+    onKeyPress(listener: (event: TestKeymapEvent) => void): () => void;
+    onKeyRelease(listener: (event: TestKeymapEvent) => void): () => void;
+    onFocusChange(listener: (target: TestKeymapTarget | null) => void): () => void;
+    onDestroy(listener: () => void): () => void;
+    onTargetDestroy(target: TestKeymapTarget, listener: () => void): () => void;
+    onRawInput(listener: (sequence: string) => boolean): () => void;
+    createCommandEvent(): TestKeymapEvent;
+    focus(target: TestKeymapTarget | null): void;
+    press(name: string, modifiers?: TestKeyModifierOptions): TestKeymapEvent;
+    release(name: string, modifiers?: TestKeyModifierOptions): TestKeymapEvent;
+    raw(sequence: string): boolean;
+    destroyTarget(target: TestKeymapTarget): void;
+    destroy(): void;
+}
+export declare function createTestHostMetadata(options?: HostMetadata | TestHostMetadataOptions): HostMetadata;
+export declare function createTestKeymapHost(options?: CreateTestKeymapHostOptions): TestKeymapHost;
+export declare function createTestKeymap(options?: CreateTestKeymapOptions): TestKeymapHarness;
+export declare function captureKeymapDiagnostics(keymap: Keymap<any, any>): TestDiagnosticCapture;

package/src/testing/index.js

@@ -0,0 +1,276 @@
+// @bun
+// src/testing/index.ts
+import { Keymap } from "@opentui/keymap";
+import { registerDefaultKeys } from "@opentui/keymap/addons";
+var DEFAULT_TEST_HOST_METADATA = Object.freeze({
+  platform: "unknown",
+  primaryModifier: "unknown",
+  modifiers: Object.freeze({
+    ctrl: "unknown",
+    shift: "unknown",
+    meta: "unknown",
+    super: "unknown",
+    hyper: "unknown"
+  })
+});
+
+class TestKeymapTarget {
+  id;
+  parent = null;
+  isDestroyed = false;
+  constructor(id) {
+    this.id = id;
+  }
+  append(child) {
+    child.parent = this;
+    return child;
+  }
+}
+
+class TestKeymapEvent {
+  name;
+  ctrl;
+  shift;
+  meta;
+  super;
+  hyper;
+  propagationStopped = false;
+  defaultPrevented = false;
+  constructor(name, modifiers) {
+    this.name = name;
+    this.ctrl = modifiers?.ctrl ?? false;
+    this.shift = modifiers?.shift ?? false;
+    this.meta = modifiers?.meta ?? false;
+    this.super = modifiers?.super ?? false;
+    this.hyper = modifiers?.hyper || undefined;
+  }
+  preventDefault() {
+    this.defaultPrevented = true;
+  }
+  stopPropagation() {
+    this.propagationStopped = true;
+  }
+}
+
+class TestKeymapHost {
+  metadata;
+  rootTarget;
+  isDestroyed = false;
+  focusedTarget = null;
+  keyPressListeners = new Set;
+  keyReleaseListeners = new Set;
+  focusListeners = new Set;
+  destroyListeners = new Set;
+  rawListeners = new Set;
+  targetDestroyListeners = new WeakMap;
+  constructor(options) {
+    this.metadata = normalizeTestHostMetadata(options?.metadata);
+    this.rootTarget = new TestKeymapTarget("root");
+  }
+  createTarget(id) {
+    return new TestKeymapTarget(id);
+  }
+  getFocusedTarget() {
+    return this.focusedTarget && !this.focusedTarget.isDestroyed ? this.focusedTarget : null;
+  }
+  getParentTarget(target) {
+    return target.parent;
+  }
+  isTargetDestroyed(target) {
+    return target.isDestroyed;
+  }
+  onKeyPress(listener) {
+    this.keyPressListeners.add(listener);
+    return () => {
+      this.keyPressListeners.delete(listener);
+    };
+  }
+  onKeyRelease(listener) {
+    this.keyReleaseListeners.add(listener);
+    return () => {
+      this.keyReleaseListeners.delete(listener);
+    };
+  }
+  onFocusChange(listener) {
+    this.focusListeners.add(listener);
+    return () => {
+      this.focusListeners.delete(listener);
+    };
+  }
+  onDestroy(listener) {
+    this.destroyListeners.add(listener);
+    return () => {
+      this.destroyListeners.delete(listener);
+    };
+  }
+  onTargetDestroy(target, listener) {
+    let listeners = this.targetDestroyListeners.get(target);
+    if (!listeners) {
+      listeners = new Set;
+      this.targetDestroyListeners.set(target, listeners);
+    }
+    listeners.add(listener);
+    return () => {
+      listeners?.delete(listener);
+      if (listeners && listeners.size === 0) {
+        this.targetDestroyListeners.delete(target);
+      }
+    };
+  }
+  onRawInput(listener) {
+    this.rawListeners.add(listener);
+    return () => {
+      this.rawListeners.delete(listener);
+    };
+  }
+  createCommandEvent() {
+    return new TestKeymapEvent("synthetic");
+  }
+  focus(target) {
+    this.focusedTarget = target;
+    for (const listener of this.focusListeners) {
+      listener(target);
+    }
+  }
+  press(name, modifiers) {
+    const event = new TestKeymapEvent(name, modifiers);
+    for (const listener of this.keyPressListeners) {
+      listener(event);
+    }
+    return event;
+  }
+  release(name, modifiers) {
+    const event = new TestKeymapEvent(name, modifiers);
+    for (const listener of this.keyReleaseListeners) {
+      listener(event);
+    }
+    return event;
+  }
+  raw(sequence) {
+    let handled = false;
+    for (const listener of this.rawListeners) {
+      handled = listener(sequence) || handled;
+    }
+    return handled;
+  }
+  destroyTarget(target) {
+    target.isDestroyed = true;
+    const listeners = this.targetDestroyListeners.get(target);
+    if (!listeners) {
+      return;
+    }
+    for (const listener of [...listeners]) {
+      listener();
+    }
+  }
+  destroy() {
+    if (this.isDestroyed) {
+      return;
+    }
+    this.isDestroyed = true;
+    for (const listener of [...this.destroyListeners]) {
+      listener();
+    }
+  }
+}
+function createTestHostMetadata(options) {
+  return normalizeTestHostMetadata(options);
+}
+function createTestKeymapHost(options) {
+  return new TestKeymapHost(options);
+}
+function createTestKeymap(options) {
+  const host = createTestKeymapHost(options);
+  const keymap = new Keymap(host);
+  const diagnostics = captureKeymapDiagnostics(keymap);
+  if (options?.defaultKeys === true) {
+    registerDefaultKeys(keymap);
+  }
+  return {
+    keymap,
+    host,
+    root: host.rootTarget,
+    diagnostics,
+    cleanup() {
+      host.destroy();
+      diagnostics.dispose();
+    }
+  };
+}
+function captureKeymapDiagnostics(keymap) {
+  const warnings = [];
+  const errors = [];
+  const warningEvents = [];
+  const errorEvents = [];
+  const offWarning = keymap.on("warning", (event) => {
+    warnings.push(event.message);
+    warningEvents.push(event);
+  });
+  const offError = keymap.on("error", (event) => {
+    errors.push(event.message);
+    errorEvents.push(event);
+  });
+  return {
+    warnings,
+    errors,
+    warningEvents,
+    errorEvents,
+    takeWarnings() {
+      const snapshot = {
+        warnings: [...warnings],
+        warningEvents: [...warningEvents]
+      };
+      warnings.length = 0;
+      warningEvents.length = 0;
+      return snapshot;
+    },
+    takeErrors() {
+      const snapshot = {
+        errors: [...errors],
+        errorEvents: [...errorEvents]
+      };
+      errors.length = 0;
+      errorEvents.length = 0;
+      return snapshot;
+    },
+    clear() {
+      warnings.length = 0;
+      errors.length = 0;
+      warningEvents.length = 0;
+      errorEvents.length = 0;
+    },
+    dispose() {
+      offWarning();
+      offError();
+    }
+  };
+}
+function normalizeTestHostMetadata(metadata) {
+  if (isHostMetadata(metadata)) {
+    return metadata;
+  }
+  return {
+    platform: metadata?.platform ?? DEFAULT_TEST_HOST_METADATA.platform,
+    primaryModifier: metadata?.primaryModifier ?? DEFAULT_TEST_HOST_METADATA.primaryModifier,
+    modifiers: {
+      ...DEFAULT_TEST_HOST_METADATA.modifiers,
+      ...metadata?.modifiers
+    }
+  };
+}
+function isHostMetadata(value) {
+  return !!value && !!value.modifiers && "ctrl" in value.modifiers && "shift" in value.modifiers;
+}
+export {
+  createTestKeymapHost,
+  createTestKeymap,
+  createTestHostMetadata,
+  captureKeymapDiagnostics,
+  TestKeymapTarget,
+  TestKeymapHost,
+  TestKeymapEvent,
+  DEFAULT_TEST_HOST_METADATA
+};
+
+//# debugId=AC56D442CF81C26564756E2164756E21
+//# sourceMappingURL=index.js.map

package/src/testing/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/testing/index.ts"],
+  "sourcesContent": [
+    "import { Keymap } from \"@opentui/keymap\"\nimport { registerDefaultKeys } from \"@opentui/keymap/addons\"\nimport type { ErrorEvent, HostMetadata, KeymapEvent, KeymapHost, WarningEvent } from \"@opentui/keymap\"\n\nexport type TestKeyModifierOptions = Partial<Pick<KeymapEvent, \"ctrl\" | \"shift\" | \"meta\" | \"super\" | \"hyper\">>\n\nexport type TestHostMetadataOptions = Partial<Omit<HostMetadata, \"modifiers\">> & {\n  modifiers?: Partial<HostMetadata[\"modifiers\"]>\n}\n\nexport interface CreateTestKeymapHostOptions {\n  metadata?: HostMetadata | TestHostMetadataOptions\n}\n\nexport interface CreateTestKeymapOptions extends CreateTestKeymapHostOptions {\n  defaultKeys?: boolean\n}\n\nexport interface TestDiagnosticCapture {\n  readonly warnings: readonly string[]\n  readonly errors: readonly string[]\n  readonly warningEvents: readonly WarningEvent[]\n  readonly errorEvents: readonly ErrorEvent[]\n  takeWarnings(): { warnings: string[]; warningEvents: WarningEvent[] }\n  takeErrors(): { errors: string[]; errorEvents: ErrorEvent[] }\n  clear(): void\n  dispose(): void\n}\n\nexport interface TestKeymapHarness {\n  keymap: Keymap<TestKeymapTarget, TestKeymapEvent>\n  host: TestKeymapHost\n  root: TestKeymapTarget\n  diagnostics: TestDiagnosticCapture\n  cleanup(): void\n}\n\nexport const DEFAULT_TEST_HOST_METADATA: HostMetadata = Object.freeze({\n  platform: \"unknown\",\n  primaryModifier: \"unknown\",\n  modifiers: Object.freeze({\n    ctrl: \"unknown\",\n    shift: \"unknown\",\n    meta: \"unknown\",\n    super: \"unknown\",\n    hyper: \"unknown\",\n  }),\n})\n\nexport class TestKeymapTarget {\n  public parent: TestKeymapTarget | null = null\n  public isDestroyed = false\n\n  constructor(public readonly id: string) {}\n\n  public append(child: TestKeymapTarget): TestKeymapTarget {\n    child.parent = this\n    return child\n  }\n}\n\nexport class TestKeymapEvent implements KeymapEvent {\n  public readonly ctrl: boolean\n  public readonly shift: boolean\n  public readonly meta: boolean\n  public readonly super: boolean\n  public readonly hyper?: boolean\n  public propagationStopped = false\n  public defaultPrevented = false\n\n  constructor(\n    public readonly name: string,\n    modifiers?: TestKeyModifierOptions,\n  ) {\n    this.ctrl = modifiers?.ctrl ?? false\n    this.shift = modifiers?.shift ?? false\n    this.meta = modifiers?.meta ?? false\n    this.super = modifiers?.super ?? false\n    this.hyper = modifiers?.hyper || undefined\n  }\n\n  public preventDefault(): void {\n    this.defaultPrevented = true\n  }\n\n  public stopPropagation(): void {\n    this.propagationStopped = true\n  }\n}\n\nexport class TestKeymapHost implements KeymapHost<TestKeymapTarget, TestKeymapEvent> {\n  public readonly metadata: HostMetadata\n  public readonly rootTarget: TestKeymapTarget\n  public isDestroyed = false\n\n  private focusedTarget: TestKeymapTarget | null = null\n  private readonly keyPressListeners = new Set<(event: TestKeymapEvent) => void>()\n  private readonly keyReleaseListeners = new Set<(event: TestKeymapEvent) => void>()\n  private readonly focusListeners = new Set<(target: TestKeymapTarget | null) => void>()\n  private readonly destroyListeners = new Set<() => void>()\n  private readonly rawListeners = new Set<(sequence: string) => boolean>()\n  private readonly targetDestroyListeners = new WeakMap<TestKeymapTarget, Set<() => void>>()\n\n  constructor(options?: CreateTestKeymapHostOptions) {\n    this.metadata = normalizeTestHostMetadata(options?.metadata)\n    this.rootTarget = new TestKeymapTarget(\"root\")\n  }\n\n  public createTarget(id: string): TestKeymapTarget {\n    return new TestKeymapTarget(id)\n  }\n\n  public getFocusedTarget(): TestKeymapTarget | null {\n    return this.focusedTarget && !this.focusedTarget.isDestroyed ? this.focusedTarget : null\n  }\n\n  public getParentTarget(target: TestKeymapTarget): TestKeymapTarget | null {\n    return target.parent\n  }\n\n  public isTargetDestroyed(target: TestKeymapTarget): boolean {\n    return target.isDestroyed\n  }\n\n  public onKeyPress(listener: (event: TestKeymapEvent) => void): () => void {\n    this.keyPressListeners.add(listener)\n    return () => {\n      this.keyPressListeners.delete(listener)\n    }\n  }\n\n  public onKeyRelease(listener: (event: TestKeymapEvent) => void): () => void {\n    this.keyReleaseListeners.add(listener)\n    return () => {\n      this.keyReleaseListeners.delete(listener)\n    }\n  }\n\n  public onFocusChange(listener: (target: TestKeymapTarget | null) => void): () => void {\n    this.focusListeners.add(listener)\n    return () => {\n      this.focusListeners.delete(listener)\n    }\n  }\n\n  public onDestroy(listener: () => void): () => void {\n    this.destroyListeners.add(listener)\n    return () => {\n      this.destroyListeners.delete(listener)\n    }\n  }\n\n  public onTargetDestroy(target: TestKeymapTarget, listener: () => void): () => void {\n    let listeners = this.targetDestroyListeners.get(target)\n    if (!listeners) {\n      listeners = new Set()\n      this.targetDestroyListeners.set(target, listeners)\n    }\n\n    listeners.add(listener)\n    return () => {\n      listeners?.delete(listener)\n      if (listeners && listeners.size === 0) {\n        this.targetDestroyListeners.delete(target)\n      }\n    }\n  }\n\n  public onRawInput(listener: (sequence: string) => boolean): () => void {\n    this.rawListeners.add(listener)\n    return () => {\n      this.rawListeners.delete(listener)\n    }\n  }\n\n  public createCommandEvent(): TestKeymapEvent {\n    return new TestKeymapEvent(\"synthetic\")\n  }\n\n  public focus(target: TestKeymapTarget | null): void {\n    this.focusedTarget = target\n    for (const listener of this.focusListeners) {\n      listener(target)\n    }\n  }\n\n  public press(name: string, modifiers?: TestKeyModifierOptions): TestKeymapEvent {\n    const event = new TestKeymapEvent(name, modifiers)\n    for (const listener of this.keyPressListeners) {\n      listener(event)\n    }\n\n    return event\n  }\n\n  public release(name: string, modifiers?: TestKeyModifierOptions): TestKeymapEvent {\n    const event = new TestKeymapEvent(name, modifiers)\n    for (const listener of this.keyReleaseListeners) {\n      listener(event)\n    }\n\n    return event\n  }\n\n  public raw(sequence: string): boolean {\n    let handled = false\n    for (const listener of this.rawListeners) {\n      handled = listener(sequence) || handled\n    }\n\n    return handled\n  }\n\n  public destroyTarget(target: TestKeymapTarget): void {\n    target.isDestroyed = true\n    const listeners = this.targetDestroyListeners.get(target)\n    if (!listeners) {\n      return\n    }\n\n    for (const listener of [...listeners]) {\n      listener()\n    }\n  }\n\n  public destroy(): void {\n    if (this.isDestroyed) {\n      return\n    }\n\n    this.isDestroyed = true\n    for (const listener of [...this.destroyListeners]) {\n      listener()\n    }\n  }\n}\n\nexport function createTestHostMetadata(options?: HostMetadata | TestHostMetadataOptions): HostMetadata {\n  return normalizeTestHostMetadata(options)\n}\n\nexport function createTestKeymapHost(options?: CreateTestKeymapHostOptions): TestKeymapHost {\n  return new TestKeymapHost(options)\n}\n\nexport function createTestKeymap(options?: CreateTestKeymapOptions): TestKeymapHarness {\n  const host = createTestKeymapHost(options)\n  const keymap = new Keymap(host)\n  const diagnostics = captureKeymapDiagnostics(keymap)\n\n  if (options?.defaultKeys === true) {\n    registerDefaultKeys(keymap)\n  }\n\n  return {\n    keymap,\n    host,\n    root: host.rootTarget,\n    diagnostics,\n    cleanup() {\n      host.destroy()\n      diagnostics.dispose()\n    },\n  }\n}\n\nexport function captureKeymapDiagnostics(keymap: Keymap<any, any>): TestDiagnosticCapture {\n  const warnings: string[] = []\n  const errors: string[] = []\n  const warningEvents: WarningEvent[] = []\n  const errorEvents: ErrorEvent[] = []\n\n  const offWarning = keymap.on(\"warning\", (event) => {\n    warnings.push(event.message)\n    warningEvents.push(event)\n  })\n  const offError = keymap.on(\"error\", (event) => {\n    errors.push(event.message)\n    errorEvents.push(event)\n  })\n\n  return {\n    warnings,\n    errors,\n    warningEvents,\n    errorEvents,\n    takeWarnings() {\n      const snapshot = {\n        warnings: [...warnings],\n        warningEvents: [...warningEvents],\n      }\n      warnings.length = 0\n      warningEvents.length = 0\n      return snapshot\n    },\n    takeErrors() {\n      const snapshot = {\n        errors: [...errors],\n        errorEvents: [...errorEvents],\n      }\n      errors.length = 0\n      errorEvents.length = 0\n      return snapshot\n    },\n    clear() {\n      warnings.length = 0\n      errors.length = 0\n      warningEvents.length = 0\n      errorEvents.length = 0\n    },\n    dispose() {\n      offWarning()\n      offError()\n    },\n  }\n}\n\nfunction normalizeTestHostMetadata(metadata?: HostMetadata | TestHostMetadataOptions): HostMetadata {\n  if (isHostMetadata(metadata)) {\n    return metadata\n  }\n\n  return {\n    platform: metadata?.platform ?? DEFAULT_TEST_HOST_METADATA.platform,\n    primaryModifier: metadata?.primaryModifier ?? DEFAULT_TEST_HOST_METADATA.primaryModifier,\n    modifiers: {\n      ...DEFAULT_TEST_HOST_METADATA.modifiers,\n      ...metadata?.modifiers,\n    },\n  }\n}\n\nfunction isHostMetadata(value: HostMetadata | TestHostMetadataOptions | undefined): value is HostMetadata {\n  return !!value && !!value.modifiers && \"ctrl\" in value.modifiers && \"shift\" in value.modifiers\n}\n"
+  ],
+  "mappings": ";;AAAA;AACA;AAoCO,IAAM,6BAA2C,OAAO,OAAO;AAAA,EACpE,UAAU;AAAA,EACV,iBAAiB;AAAA,EACjB,WAAW,OAAO,OAAO;AAAA,IACvB,MAAM;AAAA,IACN,OAAO;AAAA,IACP,MAAM;AAAA,IACN,OAAO;AAAA,IACP,OAAO;AAAA,EACT,CAAC;AACH,CAAC;AAAA;AAEM,MAAM,iBAAiB;AAAA,EAIA;AAAA,EAHrB,SAAkC;AAAA,EAClC,cAAc;AAAA,EAErB,WAAW,CAAiB,IAAY;AAAA,IAAZ;AAAA;AAAA,EAErB,MAAM,CAAC,OAA2C;AAAA,IACvD,MAAM,SAAS;AAAA,IACf,OAAO;AAAA;AAEX;AAAA;AAEO,MAAM,gBAAuC;AAAA,EAUhC;AAAA,EATF;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACT,qBAAqB;AAAA,EACrB,mBAAmB;AAAA,EAE1B,WAAW,CACO,MAChB,WACA;AAAA,IAFgB;AAAA,IAGhB,KAAK,OAAO,WAAW,QAAQ;AAAA,IAC/B,KAAK,QAAQ,WAAW,SAAS;AAAA,IACjC,KAAK,OAAO,WAAW,QAAQ;AAAA,IAC/B,KAAK,QAAQ,WAAW,SAAS;AAAA,IACjC,KAAK,QAAQ,WAAW,SAAS;AAAA;AAAA,EAG5B,cAAc,GAAS;AAAA,IAC5B,KAAK,mBAAmB;AAAA;AAAA,EAGnB,eAAe,GAAS;AAAA,IAC7B,KAAK,qBAAqB;AAAA;AAE9B;AAAA;AAEO,MAAM,eAAwE;AAAA,EACnE;AAAA,EACA;AAAA,EACT,cAAc;AAAA,EAEb,gBAAyC;AAAA,EAChC,oBAAoB,IAAI;AAAA,EACxB,sBAAsB,IAAI;AAAA,EAC1B,iBAAiB,IAAI;AAAA,EACrB,mBAAmB,IAAI;AAAA,EACvB,eAAe,IAAI;AAAA,EACnB,yBAAyB,IAAI;AAAA,EAE9C,WAAW,CAAC,SAAuC;AAAA,IACjD,KAAK,WAAW,0BAA0B,SAAS,QAAQ;AAAA,IAC3D,KAAK,aAAa,IAAI,iBAAiB,MAAM;AAAA;AAAA,EAGxC,YAAY,CAAC,IAA8B;AAAA,IAChD,OAAO,IAAI,iBAAiB,EAAE;AAAA;AAAA,EAGzB,gBAAgB,GAA4B;AAAA,IACjD,OAAO,KAAK,iBAAiB,CAAC,KAAK,cAAc,cAAc,KAAK,gBAAgB;AAAA;AAAA,EAG/E,eAAe,CAAC,QAAmD;AAAA,IACxE,OAAO,OAAO;AAAA;AAAA,EAGT,iBAAiB,CAAC,QAAmC;AAAA,IAC1D,OAAO,OAAO;AAAA;AAAA,EAGT,UAAU,CAAC,UAAwD;AAAA,IACxE,KAAK,kBAAkB,IAAI,QAAQ;AAAA,IACnC,OAAO,MAAM;AAAA,MACX,KAAK,kBAAkB,OAAO,QAAQ;AAAA;AAAA;AAAA,EAInC,YAAY,CAAC,UAAwD;AAAA,IAC1E,KAAK,oBAAoB,IAAI,QAAQ;AAAA,IACrC,OAAO,MAAM;AAAA,MACX,KAAK,oBAAoB,OAAO,QAAQ;AAAA;AAAA;AAAA,EAIrC,aAAa,CAAC,UAAiE;AAAA,IACpF,KAAK,eAAe,IAAI,QAAQ;AAAA,IAChC,OAAO,MAAM;AAAA,MACX,KAAK,eAAe,OAAO,QAAQ;AAAA;AAAA;AAAA,EAIhC,SAAS,CAAC,UAAkC;AAAA,IACjD,KAAK,iBAAiB,IAAI,QAAQ;AAAA,IAClC,OAAO,MAAM;AAAA,MACX,KAAK,iBAAiB,OAAO,QAAQ;AAAA;AAAA;AAAA,EAIlC,eAAe,CAAC,QAA0B,UAAkC;AAAA,IACjF,IAAI,YAAY,KAAK,uBAAuB,IAAI,MAAM;AAAA,IACtD,IAAI,CAAC,WAAW;AAAA,MACd,YAAY,IAAI;AAAA,MAChB,KAAK,uBAAuB,IAAI,QAAQ,SAAS;AAAA,IACnD;AAAA,IAEA,UAAU,IAAI,QAAQ;AAAA,IACtB,OAAO,MAAM;AAAA,MACX,WAAW,OAAO,QAAQ;AAAA,MAC1B,IAAI,aAAa,UAAU,SAAS,GAAG;AAAA,QACrC,KAAK,uBAAuB,OAAO,MAAM;AAAA,MAC3C;AAAA;AAAA;AAAA,EAIG,UAAU,CAAC,UAAqD;AAAA,IACrE,KAAK,aAAa,IAAI,QAAQ;AAAA,IAC9B,OAAO,MAAM;AAAA,MACX,KAAK,aAAa,OAAO,QAAQ;AAAA;AAAA;AAAA,EAI9B,kBAAkB,GAAoB;AAAA,IAC3C,OAAO,IAAI,gBAAgB,WAAW;AAAA;AAAA,EAGjC,KAAK,CAAC,QAAuC;AAAA,IAClD,KAAK,gBAAgB;AAAA,IACrB,WAAW,YAAY,KAAK,gBAAgB;AAAA,MAC1C,SAAS,MAAM;AAAA,IACjB;AAAA;AAAA,EAGK,KAAK,CAAC,MAAc,WAAqD;AAAA,IAC9E,MAAM,QAAQ,IAAI,gBAAgB,MAAM,SAAS;AAAA,IACjD,WAAW,YAAY,KAAK,mBAAmB;AAAA,MAC7C,SAAS,KAAK;AAAA,IAChB;AAAA,IAEA,OAAO;AAAA;AAAA,EAGF,OAAO,CAAC,MAAc,WAAqD;AAAA,IAChF,MAAM,QAAQ,IAAI,gBAAgB,MAAM,SAAS;AAAA,IACjD,WAAW,YAAY,KAAK,qBAAqB;AAAA,MAC/C,SAAS,KAAK;AAAA,IAChB;AAAA,IAEA,OAAO;AAAA;AAAA,EAGF,GAAG,CAAC,UAA2B;AAAA,IACpC,IAAI,UAAU;AAAA,IACd,WAAW,YAAY,KAAK,cAAc;AAAA,MACxC,UAAU,SAAS,QAAQ,KAAK;AAAA,IAClC;AAAA,IAEA,OAAO;AAAA;AAAA,EAGF,aAAa,CAAC,QAAgC;AAAA,IACnD,OAAO,cAAc;AAAA,IACrB,MAAM,YAAY,KAAK,uBAAuB,IAAI,MAAM;AAAA,IACxD,IAAI,CAAC,WAAW;AAAA,MACd;AAAA,IACF;AAAA,IAEA,WAAW,YAAY,CAAC,GAAG,SAAS,GAAG;AAAA,MACrC,SAAS;AAAA,IACX;AAAA;AAAA,EAGK,OAAO,GAAS;AAAA,IACrB,IAAI,KAAK,aAAa;AAAA,MACpB;AAAA,IACF;AAAA,IAEA,KAAK,cAAc;AAAA,IACnB,WAAW,YAAY,CAAC,GAAG,KAAK,gBAAgB,GAAG;AAAA,MACjD,SAAS;AAAA,IACX;AAAA;AAEJ;AAEO,SAAS,sBAAsB,CAAC,SAAgE;AAAA,EACrG,OAAO,0BAA0B,OAAO;AAAA;AAGnC,SAAS,oBAAoB,CAAC,SAAuD;AAAA,EAC1F,OAAO,IAAI,eAAe,OAAO;AAAA;AAG5B,SAAS,gBAAgB,CAAC,SAAsD;AAAA,EACrF,MAAM,OAAO,qBAAqB,OAAO;AAAA,EACzC,MAAM,SAAS,IAAI,OAAO,IAAI;AAAA,EAC9B,MAAM,cAAc,yBAAyB,MAAM;AAAA,EAEnD,IAAI,SAAS,gBAAgB,MAAM;AAAA,IACjC,oBAAoB,MAAM;AAAA,EAC5B;AAAA,EAEA,OAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,MAAM,KAAK;AAAA,IACX;AAAA,IACA,OAAO,GAAG;AAAA,MACR,KAAK,QAAQ;AAAA,MACb,YAAY,QAAQ;AAAA;AAAA,EAExB;AAAA;AAGK,SAAS,wBAAwB,CAAC,QAAiD;AAAA,EACxF,MAAM,WAAqB,CAAC;AAAA,EAC5B,MAAM,SAAmB,CAAC;AAAA,EAC1B,MAAM,gBAAgC,CAAC;AAAA,EACvC,MAAM,cAA4B,CAAC;AAAA,EAEnC,MAAM,aAAa,OAAO,GAAG,WAAW,CAAC,UAAU;AAAA,IACjD,SAAS,KAAK,MAAM,OAAO;AAAA,IAC3B,cAAc,KAAK,KAAK;AAAA,GACzB;AAAA,EACD,MAAM,WAAW,OAAO,GAAG,SAAS,CAAC,UAAU;AAAA,IAC7C,OAAO,KAAK,MAAM,OAAO;AAAA,IACzB,YAAY,KAAK,KAAK;AAAA,GACvB;AAAA,EAED,OAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,YAAY,GAAG;AAAA,MACb,MAAM,WAAW;AAAA,QACf,UAAU,CAAC,GAAG,QAAQ;AAAA,QACtB,eAAe,CAAC,GAAG,aAAa;AAAA,MAClC;AAAA,MACA,SAAS,SAAS;AAAA,MAClB,cAAc,SAAS;AAAA,MACvB,OAAO;AAAA;AAAA,IAET,UAAU,GAAG;AAAA,MACX,MAAM,WAAW;AAAA,QACf,QAAQ,CAAC,GAAG,MAAM;AAAA,QAClB,aAAa,CAAC,GAAG,WAAW;AAAA,MAC9B;AAAA,MACA,OAAO,SAAS;AAAA,MAChB,YAAY,SAAS;AAAA,MACrB,OAAO;AAAA;AAAA,IAET,KAAK,GAAG;AAAA,MACN,SAAS,SAAS;AAAA,MAClB,OAAO,SAAS;AAAA,MAChB,cAAc,SAAS;AAAA,MACvB,YAAY,SAAS;AAAA;AAAA,IAEvB,OAAO,GAAG;AAAA,MACR,WAAW;AAAA,MACX,SAAS;AAAA;AAAA,EAEb;AAAA;AAGF,SAAS,yBAAyB,CAAC,UAAiE;AAAA,EAClG,IAAI,eAAe,QAAQ,GAAG;AAAA,IAC5B,OAAO;AAAA,EACT;AAAA,EAEA,OAAO;AAAA,IACL,UAAU,UAAU,YAAY,2BAA2B;AAAA,IAC3D,iBAAiB,UAAU,mBAAmB,2BAA2B;AAAA,IACzE,WAAW;AAAA,SACN,2BAA2B;AAAA,SAC3B,UAAU;AAAA,IACf;AAAA,EACF;AAAA;AAGF,SAAS,cAAc,CAAC,OAAkF;AAAA,EACxG,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,MAAM,aAAa,UAAU,MAAM,aAAa,WAAW,MAAM;AAAA;",
+  "debugId": "AC56D442CF81C26564756E2164756E21",
+  "names": []
+}