@elizaos/tui 2.0.0-alpha.10

package/dist/components/markdown.js

@@ -0,0 +1,319 @@
+import { marked } from "marked";
+import { isImageLine } from "../terminal-image.js";
+import { applyBackgroundToLine, visibleWidth, wrapTextWithAnsi } from "../utils.js";
+import { renderInlineTokens as renderInlineTokensUtil } from "./markdown/inline-renderer.js";
+import { renderList as renderListUtil } from "./markdown/list-renderer.js";
+import { renderTable as renderTableUtil } from "./markdown/table-renderer.js";
+import { getStylePrefix } from "./markdown/types.js";
+export class Markdown {
+    text;
+    paddingX; // Left/right padding
+    paddingY; // Top/bottom padding
+    defaultTextStyle;
+    theme;
+    defaultStylePrefix;
+    // Cache for rendered output
+    cachedText;
+    cachedWidth;
+    cachedLines;
+    constructor(text, paddingX, paddingY, theme, defaultTextStyle) {
+        this.text = text;
+        this.paddingX = paddingX;
+        this.paddingY = paddingY;
+        this.theme = theme;
+        this.defaultTextStyle = defaultTextStyle;
+    }
+    setText(text) {
+        this.text = text;
+        this.invalidate();
+    }
+    invalidate() {
+        this.cachedText = undefined;
+        this.cachedWidth = undefined;
+        this.cachedLines = undefined;
+    }
+    render(width) {
+        // Check cache
+        if (this.cachedLines && this.cachedText === this.text && this.cachedWidth === width) {
+            return this.cachedLines;
+        }
+        // Calculate available width for content (subtract horizontal padding)
+        const contentWidth = Math.max(1, width - this.paddingX * 2);
+        // Don't render anything if there's no actual text
+        if (!this.text || this.text.trim() === "") {
+            const result = [];
+            // Update cache
+            this.cachedText = this.text;
+            this.cachedWidth = width;
+            this.cachedLines = result;
+            return result;
+        }
+        // Replace tabs with 3 spaces for consistent rendering
+        const normalizedText = this.text.replace(/\t/g, "   ");
+        // Parse markdown to HTML-like tokens
+        const tokens = marked.lexer(normalizedText);
+        // Convert tokens to styled terminal output
+        const renderedLines = [];
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            const nextToken = tokens[i + 1];
+            const tokenLines = this.renderToken(token, contentWidth, nextToken?.type);
+            renderedLines.push(...tokenLines);
+        }
+        // Wrap lines (NO padding, NO background yet)
+        const wrappedLines = [];
+        for (const line of renderedLines) {
+            if (isImageLine(line)) {
+                wrappedLines.push(line);
+            }
+            else {
+                wrappedLines.push(...wrapTextWithAnsi(line, contentWidth));
+            }
+        }
+        // Add margins and background to each wrapped line
+        const leftMargin = " ".repeat(this.paddingX);
+        const rightMargin = " ".repeat(this.paddingX);
+        const backgroundFn = this.defaultTextStyle?.bgColor;
+        const contentLines = [];
+        for (const line of wrappedLines) {
+            if (isImageLine(line)) {
+                contentLines.push(line);
+                continue;
+            }
+            const lineWithMargins = leftMargin + line + rightMargin;
+            if (backgroundFn) {
+                contentLines.push(applyBackgroundToLine(lineWithMargins, width, backgroundFn));
+            }
+            else {
+                // No background - just pad to width
+                const visibleLen = visibleWidth(lineWithMargins);
+                const paddingNeeded = Math.max(0, width - visibleLen);
+                contentLines.push(lineWithMargins + " ".repeat(paddingNeeded));
+            }
+        }
+        // Add top/bottom padding (empty lines)
+        const emptyLine = " ".repeat(width);
+        const emptyLines = [];
+        for (let i = 0; i < this.paddingY; i++) {
+            const line = backgroundFn ? applyBackgroundToLine(emptyLine, width, backgroundFn) : emptyLine;
+            emptyLines.push(line);
+        }
+        // Combine top padding, content, and bottom padding
+        const result = [...emptyLines, ...contentLines, ...emptyLines];
+        // Update cache
+        this.cachedText = this.text;
+        this.cachedWidth = width;
+        this.cachedLines = result;
+        return result.length > 0 ? result : [""];
+    }
+    /**
+     * Apply default text style to a string.
+     * This is the base styling applied to all text content.
+     * NOTE: Background color is NOT applied here - it's applied at the padding stage
+     * to ensure it extends to the full line width.
+     */
+    applyDefaultStyle(text) {
+        if (!this.defaultTextStyle) {
+            return text;
+        }
+        let styled = text;
+        // Apply foreground color (NOT background - that's applied at padding stage)
+        if (this.defaultTextStyle.color) {
+            styled = this.defaultTextStyle.color(styled);
+        }
+        // Apply text decorations using this.theme
+        if (this.defaultTextStyle.bold) {
+            styled = this.theme.bold(styled);
+        }
+        if (this.defaultTextStyle.italic) {
+            styled = this.theme.italic(styled);
+        }
+        if (this.defaultTextStyle.strikethrough) {
+            styled = this.theme.strikethrough(styled);
+        }
+        if (this.defaultTextStyle.underline) {
+            styled = this.theme.underline(styled);
+        }
+        return styled;
+    }
+    getDefaultStylePrefix() {
+        if (!this.defaultTextStyle) {
+            return "";
+        }
+        if (this.defaultStylePrefix !== undefined) {
+            return this.defaultStylePrefix;
+        }
+        const sentinel = "\u0000";
+        let styled = sentinel;
+        if (this.defaultTextStyle.color) {
+            styled = this.defaultTextStyle.color(styled);
+        }
+        if (this.defaultTextStyle.bold) {
+            styled = this.theme.bold(styled);
+        }
+        if (this.defaultTextStyle.italic) {
+            styled = this.theme.italic(styled);
+        }
+        if (this.defaultTextStyle.strikethrough) {
+            styled = this.theme.strikethrough(styled);
+        }
+        if (this.defaultTextStyle.underline) {
+            styled = this.theme.underline(styled);
+        }
+        const sentinelIndex = styled.indexOf(sentinel);
+        this.defaultStylePrefix = sentinelIndex >= 0 ? styled.slice(0, sentinelIndex) : "";
+        return this.defaultStylePrefix;
+    }
+    // Use imported getStylePrefix from markdown/types.js
+    getDefaultInlineStyleContext() {
+        return {
+            applyText: (text) => this.applyDefaultStyle(text),
+            stylePrefix: this.getDefaultStylePrefix(),
+        };
+    }
+    renderToken(token, width, nextTokenType) {
+        const lines = [];
+        switch (token.type) {
+            case "heading": {
+                const headingLevel = token.depth;
+                const headingPrefix = `${"#".repeat(headingLevel)} `;
+                const headingText = this.renderInlineTokens(token.tokens || []);
+                let styledHeading;
+                if (headingLevel === 1) {
+                    styledHeading = this.theme.heading(this.theme.bold(this.theme.underline(headingText)));
+                }
+                else if (headingLevel === 2) {
+                    styledHeading = this.theme.heading(this.theme.bold(headingText));
+                }
+                else {
+                    styledHeading = this.theme.heading(this.theme.bold(headingPrefix + headingText));
+                }
+                lines.push(styledHeading);
+                if (nextTokenType !== "space") {
+                    lines.push(""); // Add spacing after headings (unless space token follows)
+                }
+                break;
+            }
+            case "paragraph": {
+                const paragraphText = this.renderInlineTokens(token.tokens || []);
+                lines.push(paragraphText);
+                // Don't add spacing if next token is space or list
+                if (nextTokenType && nextTokenType !== "list" && nextTokenType !== "space") {
+                    lines.push("");
+                }
+                break;
+            }
+            case "code": {
+                const indent = this.theme.codeBlockIndent ?? "  ";
+                lines.push(this.theme.codeBlockBorder(`\`\`\`${token.lang || ""}`));
+                if (this.theme.highlightCode) {
+                    const highlightedLines = this.theme.highlightCode(token.text, token.lang);
+                    for (const hlLine of highlightedLines) {
+                        lines.push(`${indent}${hlLine}`);
+                    }
+                }
+                else {
+                    // Split code by newlines and style each line
+                    const codeLines = token.text.split("\n");
+                    for (const codeLine of codeLines) {
+                        lines.push(`${indent}${this.theme.codeBlock(codeLine)}`);
+                    }
+                }
+                lines.push(this.theme.codeBlockBorder("```"));
+                if (nextTokenType !== "space") {
+                    lines.push(""); // Add spacing after code blocks (unless space token follows)
+                }
+                break;
+            }
+            case "list": {
+                const listLines = this.renderList(token, 0);
+                lines.push(...listLines);
+                // Don't add spacing after lists if a space token follows
+                // (the space token will handle it)
+                break;
+            }
+            case "table": {
+                const tableLines = this.renderTable(token, width);
+                lines.push(...tableLines);
+                break;
+            }
+            case "blockquote": {
+                const quoteStyle = (text) => this.theme.quote(this.theme.italic(text));
+                const quoteStyleContext = {
+                    applyText: quoteStyle,
+                    stylePrefix: getStylePrefix(quoteStyle),
+                };
+                const quoteText = this.renderInlineTokens(token.tokens || [], quoteStyleContext);
+                const quoteLines = quoteText.split("\n");
+                // Calculate available width for quote content (subtract border "│ " = 2 chars)
+                const quoteContentWidth = Math.max(1, width - 2);
+                for (const quoteLine of quoteLines) {
+                    // Wrap the styled line, then add border to each wrapped line
+                    const wrappedLines = wrapTextWithAnsi(quoteLine, quoteContentWidth);
+                    for (const wrappedLine of wrappedLines) {
+                        lines.push(this.theme.quoteBorder("│ ") + wrappedLine);
+                    }
+                }
+                if (nextTokenType !== "space") {
+                    lines.push(""); // Add spacing after blockquotes (unless space token follows)
+                }
+                break;
+            }
+            case "hr":
+                lines.push(this.theme.hr("─".repeat(Math.min(width, 80))));
+                if (nextTokenType !== "space") {
+                    lines.push(""); // Add spacing after horizontal rules (unless space token follows)
+                }
+                break;
+            case "html":
+                // Render HTML as plain text (escaped for terminal)
+                if ("raw" in token && typeof token.raw === "string") {
+                    lines.push(this.applyDefaultStyle(token.raw.trim()));
+                }
+                break;
+            case "space":
+                // Space tokens represent blank lines in markdown
+                lines.push("");
+                break;
+            default:
+                // Handle any other token types as plain text
+                if ("text" in token && typeof token.text === "string") {
+                    lines.push(token.text);
+                }
+        }
+        return lines;
+    }
+    /**
+     * Render inline tokens to styled text.
+     * Delegates to the extracted inline-renderer utility.
+     */
+    renderInlineTokens(tokens, styleContext) {
+        const context = {
+            theme: this.theme,
+            getDefaultInlineStyleContext: () => this.getDefaultInlineStyleContext(),
+        };
+        return renderInlineTokensUtil(tokens, context, styleContext);
+    }
+    /**
+     * Render a list with proper nesting support.
+     * Delegates to the extracted list-renderer utility.
+     */
+    renderList(token, depth) {
+        const context = {
+            theme: this.theme,
+            renderInlineTokens: (tokens, styleContext) => this.renderInlineTokens(tokens, styleContext),
+        };
+        return renderListUtil(token, depth, context);
+    }
+    /**
+     * Render a table with width-aware cell wrapping.
+     * Delegates to the extracted table-renderer utility.
+     */
+    renderTable(token, availableWidth) {
+        const context = {
+            theme: this.theme,
+            renderInlineTokens: (tokens, styleContext) => this.renderInlineTokens(tokens, styleContext),
+        };
+        return renderTableUtil(token, availableWidth, context);
+    }
+}

package/dist/components/progress-bar.d.ts

@@ -0,0 +1,67 @@
+/**
+ * ProgressBar component for displaying progress indicators.
+ */
+import type { Component } from "../tui.js";
+/**
+ * Theme functions for ProgressBar styling.
+ */
+export interface ProgressBarTheme {
+    /** Style function for the filled portion of the bar */
+    filled: (text: string) => string;
+    /** Style function for the empty portion of the bar */
+    empty: (text: string) => string;
+    /** Style function for the percentage label */
+    label?: (text: string) => string;
+    /** Style function for the optional message */
+    message?: (text: string) => string;
+}
+/**
+ * Options for ProgressBar configuration.
+ */
+export interface ProgressBarOptions {
+    /** Theme for styling the progress bar */
+    theme?: ProgressBarTheme;
+    /** Character to use for the filled portion (default: "█") */
+    filledChar?: string;
+    /** Character to use for the empty portion (default: "░") */
+    emptyChar?: string;
+    /** Whether to show percentage label (default: true) */
+    showPercentage?: boolean;
+    /** Optional message to display */
+    message?: string;
+    /** Horizontal padding (default: 0) */
+    paddingX?: number;
+    /** Width of the bar portion (default: auto-calculate) */
+    barWidth?: number;
+}
+/**
+ * ProgressBar component that displays a visual progress indicator.
+ *
+ * Features:
+ * - Configurable filled/empty characters
+ * - Optional percentage label
+ * - Optional message
+ * - Theming support
+ */
+export declare class ProgressBar implements Component {
+    private progress;
+    private theme;
+    private filledChar;
+    private emptyChar;
+    private showPercentage;
+    private message?;
+    private paddingX;
+    private barWidth?;
+    private cachedProgress?;
+    private cachedWidth?;
+    private cachedMessage?;
+    private cachedLines?;
+    constructor(progress?: number, options?: ProgressBarOptions);
+    setProgress(progress: number): void;
+    getProgress(): number;
+    setMessage(message?: string): void;
+    setTheme(theme: ProgressBarTheme): void;
+    invalidate(): void;
+    render(width: number): string[];
+}
+//# sourceMappingURL=progress-bar.d.ts.map

package/dist/components/progress-bar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-bar.d.ts","sourceRoot":"","sources":["../../src/components/progress-bar.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAG3C;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC,uDAAuD;IACvD,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACjC,sDAAsD;IACtD,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAChC,8CAA8C;IAC9C,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACjC,8CAA8C;IAC9C,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC,yCAAyC;IACzC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uDAAuD;IACvD,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kCAAkC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAYD;;;;;;;;GAQG;AACH,qBAAa,WAAY,YAAW,SAAS;IAC5C,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,cAAc,CAAU;IAChC,OAAO,CAAC,OAAO,CAAC,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAC,CAAS;IAG1B,OAAO,CAAC,cAAc,CAAC,CAAS;IAChC,OAAO,CAAC,WAAW,CAAC,CAAS;IAC7B,OAAO,CAAC,aAAa,CAAC,CAAS;IAC/B,OAAO,CAAC,WAAW,CAAC,CAAW;gBAEnB,QAAQ,SAAI,EAAE,OAAO,GAAE,kBAAuB;IAW1D,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAKnC,WAAW,IAAI,MAAM;IAIrB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAKlC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAKvC,UAAU,IAAI,IAAI;IAOlB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;CAmE/B"}

package/dist/components/progress-bar.js

@@ -0,0 +1,124 @@
+/**
+ * ProgressBar component for displaying progress indicators.
+ */
+import { visibleWidth } from "../utils.js";
+/**
+ * Default theme with no styling.
+ */
+const DEFAULT_THEME = {
+    filled: (text) => text,
+    empty: (text) => text,
+    label: (text) => text,
+    message: (text) => text,
+};
+/**
+ * ProgressBar component that displays a visual progress indicator.
+ *
+ * Features:
+ * - Configurable filled/empty characters
+ * - Optional percentage label
+ * - Optional message
+ * - Theming support
+ */
+export class ProgressBar {
+    progress; // 0-1 range
+    theme;
+    filledChar;
+    emptyChar;
+    showPercentage;
+    message;
+    paddingX;
+    barWidth;
+    // Cache
+    cachedProgress;
+    cachedWidth;
+    cachedMessage;
+    cachedLines;
+    constructor(progress = 0, options = {}) {
+        this.progress = Math.max(0, Math.min(1, progress));
+        this.theme = options.theme ?? DEFAULT_THEME;
+        this.filledChar = options.filledChar ?? "█";
+        this.emptyChar = options.emptyChar ?? "░";
+        this.showPercentage = options.showPercentage ?? true;
+        this.message = options.message;
+        this.paddingX = options.paddingX ?? 0;
+        this.barWidth = options.barWidth;
+    }
+    setProgress(progress) {
+        this.progress = Math.max(0, Math.min(1, progress));
+        this.invalidate();
+    }
+    getProgress() {
+        return this.progress;
+    }
+    setMessage(message) {
+        this.message = message;
+        this.invalidate();
+    }
+    setTheme(theme) {
+        this.theme = theme;
+        this.invalidate();
+    }
+    invalidate() {
+        this.cachedProgress = undefined;
+        this.cachedWidth = undefined;
+        this.cachedMessage = undefined;
+        this.cachedLines = undefined;
+    }
+    render(width) {
+        // Check cache
+        if (this.cachedLines &&
+            this.cachedProgress === this.progress &&
+            this.cachedWidth === width &&
+            this.cachedMessage === this.message) {
+            return this.cachedLines;
+        }
+        const contentWidth = Math.max(1, width - this.paddingX * 2);
+        const leftPad = " ".repeat(this.paddingX);
+        // Calculate percentage label
+        const percentLabel = this.showPercentage ? `${Math.round(this.progress * 100)}%` : "";
+        const percentLabelWidth = this.showPercentage ? visibleWidth(percentLabel) + 1 : 0; // +1 for space
+        // Calculate bar width
+        let barWidth;
+        if (this.barWidth !== undefined) {
+            barWidth = Math.max(1, Math.min(this.barWidth, contentWidth - percentLabelWidth));
+        }
+        else {
+            barWidth = Math.max(1, contentWidth - percentLabelWidth);
+        }
+        // Calculate filled/empty portions
+        const filledWidth = Math.round(barWidth * this.progress);
+        const emptyWidth = barWidth - filledWidth;
+        // Build the bar
+        const filledPart = this.theme.filled(this.filledChar.repeat(filledWidth));
+        const emptyPart = this.theme.empty(this.emptyChar.repeat(emptyWidth));
+        const bar = filledPart + emptyPart;
+        // Build the line
+        let line;
+        if (this.showPercentage) {
+            const styledLabel = this.theme.label ? this.theme.label(percentLabel) : percentLabel;
+            line = `${bar} ${styledLabel}`;
+        }
+        else {
+            line = bar;
+        }
+        // Pad to width
+        const lineWidth = visibleWidth(line);
+        const padding = Math.max(0, contentWidth - lineWidth);
+        const paddedLine = leftPad + line + " ".repeat(padding) + " ".repeat(this.paddingX);
+        const lines = [paddedLine];
+        // Add message line if present
+        if (this.message) {
+            const styledMessage = this.theme.message ? this.theme.message(this.message) : this.message;
+            const msgWidth = visibleWidth(styledMessage);
+            const msgPadding = Math.max(0, contentWidth - msgWidth);
+            lines.push(leftPad + styledMessage + " ".repeat(msgPadding) + " ".repeat(this.paddingX));
+        }
+        // Update cache
+        this.cachedProgress = this.progress;
+        this.cachedWidth = width;
+        this.cachedMessage = this.message;
+        this.cachedLines = lines;
+        return lines;
+    }
+}

package/dist/components/select-list.d.ts

@@ -0,0 +1,32 @@
+import type { Component } from "../tui.js";
+export interface SelectItem {
+    value: string;
+    label: string;
+    description?: string;
+}
+export interface SelectListTheme {
+    selectedPrefix: (text: string) => string;
+    selectedText: (text: string) => string;
+    description: (text: string) => string;
+    scrollInfo: (text: string) => string;
+    noMatch: (text: string) => string;
+}
+export declare class SelectList implements Component {
+    private items;
+    private filteredItems;
+    private selectedIndex;
+    private maxVisible;
+    private theme;
+    onSelect?: (item: SelectItem) => void;
+    onCancel?: () => void;
+    onSelectionChange?: (item: SelectItem) => void;
+    constructor(items: SelectItem[], maxVisible: number, theme: SelectListTheme);
+    setFilter(filter: string): void;
+    setSelectedIndex(index: number): void;
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(keyData: string): void;
+    private notifySelectionChange;
+    getSelectedItem(): SelectItem | null;
+}
+//# sourceMappingURL=select-list.d.ts.map

package/dist/components/select-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-list.d.ts","sourceRoot":"","sources":["../../src/components/select-list.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAK3C,MAAM,WAAW,UAAU;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC/B,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACzC,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACvC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACtC,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACrC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CAClC;AAED,qBAAa,UAAW,YAAW,SAAS;IAC3C,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,aAAa,CAAoB;IACzC,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,KAAK,CAAkB;IAExB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;gBAE1C,KAAK,EAAE,UAAU,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe;IAO3E,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM/B,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIrC,UAAU,IAAI,IAAI;IAIlB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;IAiG/B,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IA2BlC,OAAO,CAAC,qBAAqB;IAO7B,eAAe,IAAI,UAAU,GAAG,IAAI;CAIpC"}