indusagi 0.13.6 → 0.13.7

package/dist/types/tracing/sinks/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * The sinks layer — public surface.
- *
- * The {@link Sink} contract (`drain`/`flush?`/`close?`) and its concrete
- * implementations: {@link ConsoleSink} (one pretty line per closed segment),
- * {@link FileSink} (NDJSON of {@link TraceRecord}s appended to a path), and
- * {@link StreamSink} (JSON lines to an injected `Writable`). Each consumes a
- * {@link import('../channel/signal').SignalChannel} and writes somewhere.
- */
-export type { Sink } from "./base";
-export { ConsoleSink } from "./console";
-export type { ConsoleSinkOptions } from "./console";
-export { FileSink } from "./file";
-export type { FileSinkOptions } from "./file";
-export { StreamSink } from "./stream";
-export type { StreamSinkOptions } from "./stream";

package/dist/types/tracing/sinks/stream.d.ts

@@ -1,46 +0,0 @@
-/**
- * {@link StreamSink}: writes closed segments to an injected {@link Writable}.
- *
- * It drains a {@link SignalChannel} and, for every `close` signal, serializes the
- * {@link TraceRecord} to a JSON line and writes it to a caller-provided
- * `node:stream` {@link Writable} — `process.stdout`, a file write stream, a
- * network socket, a `PassThrough` in tests. This is the most general sink: the
- * destination is whatever Writable you hand it.
- *
- * Backpressure is honoured. When `write` returns `false` (the stream's internal
- * buffer is full) the sink awaits the next `drain` event before continuing, so a
- * slow consumer throttles the trace rather than ballooning memory. {@link close}
- * optionally ends the underlying stream when the sink was told it owns it.
- */
-import type { Writable } from "node:stream";
-import type { SignalChannel } from "../channel/signal";
-import type { Sink } from "./base";
-/** Tuning for a {@link StreamSink}. */
-export interface StreamSinkOptions {
-    /**
-     * Whether {@link close} should `end()` the underlying stream. Defaults to
-     * `false` — by default the sink writes but never closes a stream it did not
-     * create (e.g. you would not want it ending `process.stdout`).
-     */
-    readonly endOnClose?: boolean;
-}
-/**
- * A {@link Sink} that writes each closed segment as a JSON line to a {@link Writable}.
- *
- * Owns no buffer of its own — bytes go straight to the stream — so {@link flush}
- * is a no-op resolution. {@link close} ends the stream only when constructed with
- * `endOnClose: true`.
- */
-export declare class StreamSink implements Sink {
-    private readonly stream;
-    private readonly endOnClose;
-    constructor(stream: Writable, options?: StreamSinkOptions);
-    /** Write `line`, resolving once it is accepted or once backpressure clears. */
-    private writeLine;
-    /** Drain `channel`, writing a JSON line per closed record (with backpressure). */
-    drain(channel: SignalChannel): Promise<void>;
-    /** No-op: bytes are not buffered by this sink. Present for interface symmetry. */
-    flush(): Promise<void>;
-    /** End the underlying stream when this sink owns it (`endOnClose`); else no-op. */
-    close(): Promise<void>;
-}

package/dist/types/tracing/tracing.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * Behavioural tests for the homegrown tracer: the {@link Recorder} → channel →
- * sink flow, sampling, secret redaction, and the runtime {@link traceAgentRun}
- * adapter. No network and no real timers; the {@link FileSink} writes under
- * {@link os.tmpdir}.
- */
-export {};

package/dist/types/ui/autocomplete.d.ts

@@ -1,59 +0,0 @@
-export interface AutocompleteItem {
-    value: string;
-    label: string;
-    description?: string;
-}
-export interface SlashCommand {
-    name: string;
-    description?: string;
-    getArgumentCompletions?(argumentPrefix: string): AutocompleteItem[] | null;
-}
-export interface AutocompleteProvider {
-    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): {
-        items: AutocompleteItem[];
-        prefix: string;
-    } | null;
-    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
-        lines: string[];
-        cursorLine: number;
-        cursorCol: number;
-    };
-}
-type SuggestionResult = {
-    items: AutocompleteItem[];
-    prefix: string;
-};
-export declare class CombinedAutocompleteProvider implements AutocompleteProvider {
-    private readonly basePath;
-    private readonly fdPath;
-    private readonly cache;
-    private readonly commandEngine;
-    private readonly attachmentEngine;
-    private readonly pathEngine;
-    private readonly applyStrategy;
-    constructor(commands?: (SlashCommand | AutocompleteItem)[], basePath?: string, fdPath?: string | null);
-    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): SuggestionResult | null;
-    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
-        lines: string[];
-        cursorLine: number;
-        cursorCol: number;
-    };
-    clearCache(): void;
-    getForceFileSuggestions(lines: string[], cursorLine: number, cursorCol: number): SuggestionResult | null;
-    shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean;
-}
-export interface AsyncAutocompleteProvider {
-    getSuggestionsAsync(lines: string[], cursorLine: number, cursorCol: number): Promise<{
-        items: AutocompleteItem[];
-        prefix: string;
-    } | null>;
-}
-export declare class AsyncAutocompleteChain implements AsyncAutocompleteProvider {
-    private readonly providers;
-    constructor(providers: AsyncAutocompleteProvider[]);
-    getSuggestionsAsync(lines: string[], cursorLine: number, cursorCol: number): Promise<{
-        items: AutocompleteItem[];
-        prefix: string;
-    } | null>;
-}
-export {};

package/dist/types/ui/contracts.d.ts

@@ -1,38 +0,0 @@
-export interface Component {
-    onMount?(): void;
-    onUnmount?(): void;
-    onFocus?(): void;
-    onBlur?(): void;
-    handleInput?(data: string): void;
-    render(width: number): string[];
-    invalidate(): void;
-}
-export interface TUI {
-    requestRender?(): void;
-    focus?(component: Component | null): void;
-}
-export type OverlayAnchor = "center" | "top-center" | "bottom-center" | "left-center" | "right-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
-export interface OverlayMargin {
-    left?: number;
-    right?: number;
-    top?: number;
-    bottom?: number;
-}
-export type SizeValue = number | `${number}%`;
-export interface OverlayOptions {
-    anchor?: OverlayAnchor;
-    row?: SizeValue;
-    col?: SizeValue;
-    offsetX?: number;
-    offsetY?: number;
-    margin?: OverlayMargin | number;
-    width?: SizeValue;
-    minWidth?: number;
-    maxHeight?: SizeValue;
-    visible?: (termWidth: number, termHeight: number) => boolean;
-}
-export interface OverlayHandle {
-    isHidden(): boolean;
-    setHidden(hidden: boolean): void;
-    hide(): void;
-}

package/dist/types/ui/editor-component.d.ts

@@ -1,100 +0,0 @@
-import type { AutocompleteProvider } from "./autocomplete.js";
-import type { Component } from "./contracts.js";
-/**
- * Read-only capabilities of an editor component.
- * Consumers that only need to observe state should depend on this type.
- */
-export interface EditorReadAccess {
-    /**
-     * Returns the raw text currently held in the editor buffer.
-     * Does not include any virtual or expanded markers.
-     */
-    getText(): string;
-    /**
-     * Returns the text with any inline markers expanded (e.g., paste-mode
-     * sentinels replaced by their visible representation).
-     * Falls back to `getText()` when not implemented.
-     */
-    getExpandedText?(): string;
-}
-/**
- * Mutation capabilities of an editor component.
- * Consumers that drive the editor (set content, trigger history, etc.)
- * depend on this type.
- */
-export interface EditorWriteAccess {
-    /**
-     * Replaces the entire editor buffer with the given text.
-     * The cursor is repositioned to the end of the new content.
-     */
-    setText(text: string): void;
-    /**
-     * Inserts the given text at the current cursor position,
-     * pushing existing content to the right.
-     */
-    insertTextAtCursor?(text: string): void;
-    /**
-     * Pushes the given text string into the editor's history ring
-     * so it can be recalled with Up / Down arrow navigation.
-     */
-    addToHistory?(text: string): void;
-}
-/**
- * Optional visual and autocomplete configuration for an editor component.
- */
-export interface EditorDisplayConfig {
-    /**
-     * ANSI colour-wrap function applied to the editor's border.
-     * Receives the border characters and must return a styled string.
-     */
-    borderColor?: (str: string) => string;
-    /**
-     * Sets the number of blank columns added on the left and right
-     * of the editor's content area.
-     */
-    setPaddingX?(padding: number): void;
-    /**
-     * Attaches an autocomplete provider that supplies completion candidates
-     * as the user types.
-     */
-    setAutocompleteProvider?(provider: AutocompleteProvider): void;
-    /**
-     * Returns an opaque string identifier for this component's keybinding
-     * scope, used to resolve per-component keybinding overrides.
-     */
-    getKeybindingScopeId?(): string;
-}
-/**
- * Event callbacks wired into the editor lifecycle.
- */
-export interface EditorEventCallbacks {
-    /**
-     * Fired when the user commits the current input (e.g., presses Enter).
-     * Receives the final text value at the moment of submission.
-     */
-    onSubmit?: (text: string) => void;
-    /**
-     * Fired on every keystroke or programmatic change to the buffer content.
-     * Receives the updated text after the change has been applied.
-     */
-    onChange?: (text: string) => void;
-}
-/**
- * Full interface for a pluggable editor component.
- *
- * Compose the read, write, display and callback sub-interfaces so that
- * extensions (vim mode, emacs mode, custom keybindings, etc.) remain
- * compatible with the core application while each concern is independently
- * testable.
- *
- * @example
- * ```ts
- * class VimEditor implements EditorComponent {
- *   getText() { return this.buffer; }
- *   setText(t: string) { this.buffer = t; }
- *   // ... Component lifecycle methods
- * }
- * ```
- */
-export interface EditorComponent extends Component, EditorReadAccess, EditorWriteAccess, EditorDisplayConfig, EditorEventCallbacks {
-}

package/dist/types/ui/fuzzy.d.ts

@@ -1,29 +0,0 @@
-/**
- * Helpers for approximate ("fuzzy") string matching.
- *
- * A query is considered a match when every one of its characters can be found
- * in the target string while preserving their relative order, even if other
- * characters sit between them. Each match is also given a numeric score where
- * smaller numbers indicate a tighter, more relevant match.
- */
-export interface FuzzyMatch {
-    matches: boolean;
-    score: number;
-}
-export interface FuzzyScoringConfig {
-    gapPenalty: number;
-    consecutiveReward: number;
-    wordBoundaryReward: number;
-    lateMatchPenalty: number;
-    swappedTokenPenalty: number;
-}
-export interface FuzzyMatcherStrategy {
-    match(query: string, text: string, config: FuzzyScoringConfig): FuzzyMatch;
-}
-export declare function fuzzyMatch(query: string, text: string): FuzzyMatch;
-/**
- * Keep only the items whose text fuzzy-matches the query, ordered so the
- * strongest matches come first. The query may contain several whitespace-
- * separated tokens; an item is only retained when it matches all of them.
- */
-export declare function fuzzyFilter<T>(items: T[], query: string, getText: (item: T) => string): T[];

package/dist/types/ui/index.d.ts

@@ -1,8 +0,0 @@
-export { type AutocompleteItem, type AutocompleteProvider, CombinedAutocompleteProvider, type SlashCommand, } from "./autocomplete.js";
-export type { EditorComponent } from "./editor-component.js";
-export type { Component, OverlayAnchor, OverlayHandle, OverlayMargin, OverlayOptions, SizeValue, TUI } from "./contracts.js";
-export type { EditorTheme, MarkdownTheme, SelectListTheme, SettingsListTheme } from "./theme-types.js";
-export { type FuzzyMatch, fuzzyFilter, fuzzyMatch } from "./fuzzy.js";
-export { DEFAULT_EDITOR_KEYBINDINGS, type EditorAction, type EditorKeybindingsConfig, EditorKeybindingsManager, getEditorKeybindings, setEditorKeybindings, } from "./keybindings.js";
-export { isKeyRelease, isKeyRepeat, isKittyProtocolActive, Key, type KeyEventType, type KeyId, matchesKey, parseKey, setKittyProtocolActive, } from "./keys.js";
-export { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "./utils.js";

package/dist/types/ui/keybindings.d.ts

@@ -1,62 +0,0 @@
-import { type KeyId } from "./keys.js";
-/**
- * Names of the bindable behaviors the line editor understands. Each value
- * here is a logical action that one or more physical keys may trigger.
- */
-export type EditorAction = "cursorUp" | "cursorDown" | "cursorLeft" | "cursorRight" | "cursorWordLeft" | "cursorWordRight" | "cursorLineStart" | "cursorLineEnd" | "pageUp" | "pageDown" | "deleteCharBackward" | "deleteCharForward" | "deleteWordBackward" | "deleteWordForward" | "deleteToLineStart" | "deleteToLineEnd" | "newLine" | "submit" | "tab" | "selectUp" | "selectDown" | "selectPageUp" | "selectPageDown" | "selectConfirm" | "selectCancel" | "copy" | "yank" | "yankPop" | "undo" | "expandTools" | "toggleSessionPath" | "toggleSessionSort" | "renameSession" | "deleteSession" | "deleteSessionNoninvasive";
-export type { KeyId };
-/**
- * A mapping from editor actions to the key (or keys) that should fire them.
- */
-export type EditorKeybindingsConfig = {
-    [K in EditorAction]?: KeyId | KeyId[];
-};
-export type KeybindingPreset = "default" | "vim";
-export interface KeybindingConflict {
-    key: string;
-    actions: EditorAction[];
-}
-/**
- * The keybinding layer applied to every editor before any user overrides.
- *
- * The table below is organized into category blocks (caret motion, deletion,
- * text entry, completion popup, clipboard/kill-ring, history, tool expansion,
- * session management). Each block is flattened, in declaration order, into one
- * ordered map. The flat order is preserved exactly.
- *
- * Provenance: bindings derived from GNU readline are marked "[readline]" and
- * use readline's chord exactly. Bindings unique to the indus editor are marked
- * "[indus-original]" and were picked by this project.
- */
-export declare const DEFAULT_EDITOR_KEYBINDINGS: Required<EditorKeybindingsConfig>;
-export declare const VIM_EDITOR_KEYBINDINGS: Partial<Required<EditorKeybindingsConfig>>;
-/**
- * Resolves which keys are wired to which editor action, layering presets,
- * user config, and per-component overrides on top of one another.
- */
-export declare class EditorKeybindingsManager {
-    private readonly registry;
-    private componentOverrides;
-    constructor(config?: EditorKeybindingsConfig, preset?: KeybindingPreset);
-    private rebuildRegistry;
-    private resolveKeys;
-    /**
-     * Report whether the given raw key data triggers the named action.
-     */
-    matches(data: string, action: EditorAction, componentId?: string): boolean;
-    /**
-     * List every key currently wired to the given action.
-     */
-    getKeys(action: EditorAction): KeyId[];
-    registerAction(action: EditorAction, keys: KeyId | KeyId[]): void;
-    getRegisteredActions(): EditorAction[];
-    /**
-     * Swap in a fresh config (and optional preset), rebuilding the bindings.
-     */
-    setConfig(config: EditorKeybindingsConfig, preset?: KeybindingPreset): void;
-    setComponentOverride(componentId: string, config: EditorKeybindingsConfig): void;
-    clearComponentOverride(componentId: string): void;
-    detectConflicts(): KeybindingConflict[];
-}
-export declare function getEditorKeybindings(): EditorKeybindingsManager;
-export declare function setEditorKeybindings(manager: EditorKeybindingsManager): void;

package/dist/types/ui/keys.d.ts

@@ -1,171 +0,0 @@
-/**
- * Terminal keyboard input decoding.
- *
- * This module understands two flavours of input: the older, traditional
- * escape-sequence encodings as well as the newer Kitty keyboard protocol
- * (docs at https://sw.kovidgoyal.net/kitty/keyboard-protocol/).
- *
- * Punctuation/symbol keys are recognized too. Be aware that a handful of
- * ctrl+symbol presses collide with plain ASCII control codes — ctrl+[ , for
- * instance, is indistinguishable from ESC. Despite that overlap those keys are
- * still usable in ctrl+shift combinations. The legacy-mapping background is
- * described at
- * https://sw.kovidgoyal.net/kitty/keyboard-protocol/#legacy-ctrl-mapping-of-ascii-keys.
- *
- * Public surface:
- * - matchesKey(data, keyId): test whether some raw input equals a given key id
- * - parseKey(data): decode raw input back into its key id, if recognized
- * - Key: a builder that yields strongly-typed key ids
- * - setKittyProtocolActive(active): update the shared Kitty-protocol flag
- * - isKittyProtocolActive(): read the shared Kitty-protocol flag
- */
-/**
- * Record whether the Kitty keyboard protocol is in effect. The terminal layer
- * flips this on once it has confirmed the protocol is supported.
- */
-export declare function setKittyProtocolActive(active: boolean): void;
-/**
- * Report the current value of the shared Kitty-protocol flag.
- */
-export declare function isKittyProtocolActive(): boolean;
-declare const LETTER_VALUES: readonly ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
-type Letter = (typeof LETTER_VALUES)[number];
-declare const SYMBOL_VALUES: readonly ["`", "-", "=", "[", "]", "\\", ";", "'", ",", ".", "/", "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "_", "+", "|", "~", "{", "}", ":", "<", ">", "?"];
-type SymbolKey = (typeof SYMBOL_VALUES)[number];
-declare const SPECIAL_KEY_VALUES: readonly ["escape", "esc", "enter", "return", "tab", "space", "backspace", "delete", "insert", "clear", "home", "end", "pageUp", "pageDown", "up", "down", "left", "right", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12"];
-type SpecialKey = (typeof SPECIAL_KEY_VALUES)[number];
-type BaseKey = Letter | SymbolKey | SpecialKey;
-/**
- * Every legal key-identifier string, expressed as a union. Using a literal
- * union both powers editor autocomplete and rejects malformed ids during
- * type-checking.
- */
-export type KeyId = BaseKey | `ctrl+${BaseKey}` | `shift+${BaseKey}` | `alt+${BaseKey}` | `ctrl+shift+${BaseKey}` | `shift+ctrl+${BaseKey}` | `ctrl+alt+${BaseKey}` | `alt+ctrl+${BaseKey}` | `shift+alt+${BaseKey}` | `alt+shift+${BaseKey}` | `ctrl+shift+alt+${BaseKey}` | `ctrl+alt+shift+${BaseKey}` | `shift+ctrl+alt+${BaseKey}` | `shift+alt+ctrl+${BaseKey}` | `alt+ctrl+shift+${BaseKey}` | `alt+shift+ctrl+${BaseKey}`;
-/**
- * Convenience builder that produces well-typed key ids with editor hints.
- *
- * Examples:
- * - Named keys: Key.escape, Key.enter, Key.tab, ...
- * - Punctuation: Key.backtick, Key.comma, Key.period, ...
- * - One modifier: Key.ctrl("c"), Key.alt("x")
- * - Stacked modifiers: Key.ctrlShift("p"), Key.ctrlAlt("x")
- */
-export declare const Key: {
-    readonly ctrl: <K extends BaseKey>(key: K) => `ctrl+${K}`;
-    readonly shift: <K extends BaseKey>(key: K) => `shift+${K}`;
-    readonly alt: <K extends BaseKey>(key: K) => `alt+${K}`;
-    readonly ctrlShift: <K extends BaseKey>(key: K) => `ctrl+shift+${K}`;
-    readonly shiftCtrl: <K extends BaseKey>(key: K) => `shift+ctrl+${K}`;
-    readonly ctrlAlt: <K extends BaseKey>(key: K) => `ctrl+alt+${K}`;
-    readonly altCtrl: <K extends BaseKey>(key: K) => `alt+ctrl+${K}`;
-    readonly shiftAlt: <K extends BaseKey>(key: K) => `shift+alt+${K}`;
-    readonly altShift: <K extends BaseKey>(key: K) => `alt+shift+${K}`;
-    readonly ctrlShiftAlt: <K extends BaseKey>(key: K) => `ctrl+shift+alt+${K}`;
-    readonly backtick: "`";
-    readonly hyphen: "-";
-    readonly equals: "=";
-    readonly leftbracket: "[";
-    readonly rightbracket: "]";
-    readonly backslash: "\\";
-    readonly semicolon: ";";
-    readonly quote: "'";
-    readonly comma: ",";
-    readonly period: ".";
-    readonly slash: "/";
-    readonly exclamation: "!";
-    readonly at: "@";
-    readonly hash: "#";
-    readonly dollar: "$";
-    readonly percent: "%";
-    readonly caret: "^";
-    readonly ampersand: "&";
-    readonly asterisk: "*";
-    readonly leftparen: "(";
-    readonly rightparen: ")";
-    readonly underscore: "_";
-    readonly plus: "+";
-    readonly pipe: "|";
-    readonly tilde: "~";
-    readonly leftbrace: "{";
-    readonly rightbrace: "}";
-    readonly colon: ":";
-    readonly lessthan: "<";
-    readonly greaterthan: ">";
-    readonly question: "?";
-    readonly escape: "escape";
-    readonly esc: "esc";
-    readonly enter: "enter";
-    readonly return: "return";
-    readonly tab: "tab";
-    readonly space: "space";
-    readonly backspace: "backspace";
-    readonly delete: "delete";
-    readonly insert: "insert";
-    readonly clear: "clear";
-    readonly home: "home";
-    readonly end: "end";
-    readonly pageUp: "pageUp";
-    readonly pageDown: "pageDown";
-    readonly up: "up";
-    readonly down: "down";
-    readonly left: "left";
-    readonly right: "right";
-    readonly f1: "f1";
-    readonly f2: "f2";
-    readonly f3: "f3";
-    readonly f4: "f4";
-    readonly f5: "f5";
-    readonly f6: "f6";
-    readonly f7: "f7";
-    readonly f8: "f8";
-    readonly f9: "f9";
-    readonly f10: "f10";
-    readonly f11: "f11";
-    readonly f12: "f12";
-};
-/**
- * The kind of key event the Kitty protocol reports when flag 2 is enabled.
- * Numerically: 1 means press, 2 means auto-repeat, 3 means release.
- */
-export type KeyEventType = "press" | "repeat" | "release";
-/**
- * Tell whether the supplied input represents a key being released. This is
- * only relevant while the Kitty protocol is running with flag 2 turned on.
- */
-export declare function isKeyRelease(data: string): boolean;
-/**
- * Tell whether the supplied input represents an auto-repeated key. As with
- * releases, this only carries meaning when the Kitty protocol's flag 2 is on.
- */
-export declare function isKeyRepeat(data: string): boolean;
-export declare function normalizeKeyId(keyId: string): string;
-export declare class KeyValidator {
-    normalize(keyId: string): string;
-    isValid(keyId: string): boolean;
-}
-/**
- * Decide whether raw terminal input corresponds to a particular key id.
- *
- * Identifiers it understands:
- * - Named keys such as "escape", "tab", "enter", "backspace", "delete", "home", "end", "space"
- * - The four arrows: "up", "down", "left", "right"
- * - Ctrl forms like "ctrl+c" or "ctrl+z"
- * - Shift forms like "shift+tab" or "shift+enter"
- * - Alt forms like "alt+enter" or "alt+backspace"
- * - Multi-modifier forms like "shift+ctrl+p" or "ctrl+alt+x"
- *
- * The Key builder gives you typed equivalents: Key.ctrl("c"), Key.escape, Key.ctrlShift("p").
- *
- * @param data - the bytes the terminal delivered
- * @param keyId - the identifier to test against (e.g. "ctrl+c", "escape", Key.ctrl("c"))
- */
-export declare function matchesKey(data: string, keyId: KeyId): boolean;
-/**
- * Decode raw terminal input back into its key id, or undefined when nothing
- * matches.
- *
- * @param data - the bytes the terminal delivered
- * @returns the matching key id (such as "ctrl+c"), or undefined
- */
-export declare function parseKey(data: string): string | undefined;
-export {};

package/dist/types/ui/theme-types.d.ts

@@ -1,36 +0,0 @@
-export interface SelectListTheme {
-    selectedText: (text: string) => string;
-    selectedPrefix: (text: string) => string;
-    noMatch: (text: string) => string;
-    description: (text: string) => string;
-    scrollInfo: (text: string) => string;
-}
-export interface EditorTheme {
-    selectList: SelectListTheme;
-    borderColor: (str: string) => string;
-}
-export interface MarkdownTheme {
-    heading: (text: string) => string;
-    bold: (text: string) => string;
-    italic: (text: string) => string;
-    strikethrough: (text: string) => string;
-    underline: (text: string) => string;
-    link: (text: string) => string;
-    linkUrl: (text: string) => string;
-    listBullet: (text: string) => string;
-    quote: (text: string) => string;
-    quoteBorder: (text: string) => string;
-    code: (text: string) => string;
-    codeBlock: (text: string) => string;
-    codeBlockBorder: (text: string) => string;
-    hr: (text: string) => string;
-    highlightCode?: (code: string, lang?: string) => string[];
-    codeBlockIndent?: string;
-}
-export interface SettingsListTheme {
-    cursor: string;
-    label: (text: string, selected: boolean) => string;
-    value: (text: string, selected: boolean) => string;
-    hint: (text: string) => string;
-    description: (text: string) => string;
-}