@elizaos/tui 2.0.0-alpha.10

package/dist/components/markdown/list-renderer.js

@@ -0,0 +1,110 @@
+/**
+ * List rendering utilities for Markdown component.
+ */
+/**
+ * Render a list with proper nesting support.
+ *
+ * @param token - The list token to render
+ * @param depth - Current nesting depth (0 for top-level)
+ * @param context - Rendering context with theme and inline renderer
+ * @returns Array of rendered lines
+ */
+export function renderList(token, depth, context) {
+    const lines = [];
+    const indent = "  ".repeat(depth);
+    // Use the list's start property (defaults to 1 for ordered lists)
+    const startNumber = typeof token.start === "number" ? token.start : 1;
+    for (let i = 0; i < token.items.length; i++) {
+        const item = token.items[i];
+        const bullet = token.ordered ? `${startNumber + i}. ` : "- ";
+        // Process item tokens to handle nested lists
+        const itemLines = renderListItem(item.tokens || [], depth, context);
+        if (itemLines.length > 0) {
+            // First line - check if it's a nested list
+            // A nested list will start with indent (spaces) followed by cyan bullet
+            const firstLine = itemLines[0];
+            const isNestedList = /^\s+\x1b\[36m[-\d]/.test(firstLine); // starts with spaces + cyan + bullet char
+            if (isNestedList) {
+                // This is a nested list, just add it as-is (already has full indent)
+                lines.push(firstLine);
+            }
+            else {
+                // Regular text content - add indent and bullet
+                lines.push(indent + context.theme.listBullet(bullet) + firstLine);
+            }
+            // Rest of the lines
+            for (let j = 1; j < itemLines.length; j++) {
+                const line = itemLines[j];
+                const isNestedListLine = /^\s+\x1b\[36m[-\d]/.test(line); // starts with spaces + cyan + bullet char
+                if (isNestedListLine) {
+                    // Nested list line - already has full indent
+                    lines.push(line);
+                }
+                else {
+                    // Regular content - add parent indent + 2 spaces for continuation
+                    lines.push(`${indent}  ${line}`);
+                }
+            }
+        }
+        else {
+            lines.push(indent + context.theme.listBullet(bullet));
+        }
+    }
+    return lines;
+}
+/**
+ * Render list item tokens, handling nested lists.
+ * Returns lines WITHOUT the parent indent (renderList will add it).
+ *
+ * @param tokens - Tokens from the list item
+ * @param parentDepth - Depth of the parent list
+ * @param context - Rendering context with theme and inline renderer
+ * @returns Array of rendered lines
+ */
+export function renderListItem(tokens, parentDepth, context) {
+    const lines = [];
+    for (const token of tokens) {
+        if (token.type === "list") {
+            // Nested list - render with one additional indent level
+            // These lines will have their own indent, so we just add them as-is
+            const nestedLines = renderList(token, parentDepth + 1, context);
+            lines.push(...nestedLines);
+        }
+        else if (token.type === "text") {
+            // Text content (may have inline tokens)
+            const text = token.tokens && token.tokens.length > 0 ? context.renderInlineTokens(token.tokens) : token.text || "";
+            lines.push(text);
+        }
+        else if (token.type === "paragraph") {
+            // Paragraph in list item
+            const text = context.renderInlineTokens(token.tokens || []);
+            lines.push(text);
+        }
+        else if (token.type === "code") {
+            // Code block in list item
+            const indent = context.theme.codeBlockIndent ?? "  ";
+            lines.push(context.theme.codeBlockBorder(`\`\`\`${token.lang || ""}`));
+            if (context.theme.highlightCode) {
+                const highlightedLines = context.theme.highlightCode(token.text, token.lang);
+                for (const hlLine of highlightedLines) {
+                    lines.push(`${indent}${hlLine}`);
+                }
+            }
+            else {
+                const codeLines = token.text.split("\n");
+                for (const codeLine of codeLines) {
+                    lines.push(`${indent}${context.theme.codeBlock(codeLine)}`);
+                }
+            }
+            lines.push(context.theme.codeBlockBorder("```"));
+        }
+        else {
+            // Other token types - try to render as inline
+            const text = context.renderInlineTokens([token]);
+            if (text) {
+                lines.push(text);
+            }
+        }
+    }
+    return lines;
+}

package/dist/components/markdown/table-renderer.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Table rendering utilities for Markdown component.
+ */
+import type { Token } from "marked";
+import type { TableToken } from "../../types/marked-tokens.js";
+import type { InlineStyleContext, MarkdownTheme } from "./types.js";
+/**
+ * Context for table rendering operations.
+ */
+export interface TableRenderContext {
+    theme: MarkdownTheme;
+    renderInlineTokens: (tokens: Token[], styleContext?: InlineStyleContext) => string;
+}
+/**
+ * Get the visible width of the longest word in a string.
+ *
+ * @param text - Text to analyze
+ * @param maxWidth - Optional maximum width to cap the result
+ * @returns Width of the longest word (or maxWidth if exceeded)
+ */
+export declare function getLongestWordWidth(text: string, maxWidth?: number): number;
+/**
+ * Wrap a table cell to fit into a column.
+ *
+ * Delegates to wrapTextWithAnsi() so ANSI codes + long tokens are handled
+ * consistently with the rest of the renderer.
+ *
+ * @param text - Cell text to wrap
+ * @param maxWidth - Maximum width for wrapping
+ * @returns Array of wrapped lines
+ */
+export declare function wrapCellText(text: string, maxWidth: number): string[];
+/**
+ * Render a table with width-aware cell wrapping.
+ * Cells that don't fit are wrapped to multiple lines.
+ *
+ * @param token - The table token to render
+ * @param availableWidth - Available width for the table
+ * @param context - Rendering context with theme and inline renderer
+ * @returns Array of rendered lines
+ */
+export declare function renderTable(token: TableToken, availableWidth: number, context: TableRenderContext): string[];
+//# sourceMappingURL=table-renderer.d.ts.map

package/dist/components/markdown/table-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-renderer.d.ts","sourceRoot":"","sources":["../../../src/components/markdown/table-renderer.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC,KAAK,EAAE,aAAa,CAAC;IACrB,kBAAkB,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,YAAY,CAAC,EAAE,kBAAkB,KAAK,MAAM,CAAC;CACnF;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAU3E;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAErE;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,MAAM,EAAE,CAgK5G"}

package/dist/components/markdown/table-renderer.js

@@ -0,0 +1,184 @@
+/**
+ * Table rendering utilities for Markdown component.
+ */
+import { visibleWidth, wrapTextWithAnsi } from "../../utils.js";
+/**
+ * Get the visible width of the longest word in a string.
+ *
+ * @param text - Text to analyze
+ * @param maxWidth - Optional maximum width to cap the result
+ * @returns Width of the longest word (or maxWidth if exceeded)
+ */
+export function getLongestWordWidth(text, maxWidth) {
+    const words = text.split(/\s+/).filter((word) => word.length > 0);
+    let longest = 0;
+    for (const word of words) {
+        longest = Math.max(longest, visibleWidth(word));
+    }
+    if (maxWidth === undefined) {
+        return longest;
+    }
+    return Math.min(longest, maxWidth);
+}
+/**
+ * Wrap a table cell to fit into a column.
+ *
+ * Delegates to wrapTextWithAnsi() so ANSI codes + long tokens are handled
+ * consistently with the rest of the renderer.
+ *
+ * @param text - Cell text to wrap
+ * @param maxWidth - Maximum width for wrapping
+ * @returns Array of wrapped lines
+ */
+export function wrapCellText(text, maxWidth) {
+    return wrapTextWithAnsi(text, Math.max(1, maxWidth));
+}
+/**
+ * Render a table with width-aware cell wrapping.
+ * Cells that don't fit are wrapped to multiple lines.
+ *
+ * @param token - The table token to render
+ * @param availableWidth - Available width for the table
+ * @param context - Rendering context with theme and inline renderer
+ * @returns Array of rendered lines
+ */
+export function renderTable(token, availableWidth, context) {
+    const lines = [];
+    const numCols = token.header.length;
+    if (numCols === 0) {
+        return lines;
+    }
+    // Calculate border overhead: "│ " + (n-1) * " │ " + " │"
+    // = 2 + (n-1) * 3 + 2 = 3n + 1
+    const borderOverhead = 3 * numCols + 1;
+    const availableForCells = availableWidth - borderOverhead;
+    if (availableForCells < numCols) {
+        // Too narrow to render a stable table. Fall back to raw markdown.
+        const fallbackLines = token.raw ? wrapTextWithAnsi(token.raw, availableWidth) : [];
+        fallbackLines.push("");
+        return fallbackLines;
+    }
+    const maxUnbrokenWordWidth = 30;
+    // Calculate natural column widths (what each column needs without constraints)
+    const naturalWidths = [];
+    const minWordWidths = [];
+    for (let i = 0; i < numCols; i++) {
+        const headerText = context.renderInlineTokens(token.header[i].tokens || []);
+        naturalWidths[i] = visibleWidth(headerText);
+        minWordWidths[i] = Math.max(1, getLongestWordWidth(headerText, maxUnbrokenWordWidth));
+    }
+    for (const row of token.rows) {
+        for (let i = 0; i < row.length; i++) {
+            const cellText = context.renderInlineTokens(row[i].tokens || []);
+            naturalWidths[i] = Math.max(naturalWidths[i] || 0, visibleWidth(cellText));
+            minWordWidths[i] = Math.max(minWordWidths[i] || 1, getLongestWordWidth(cellText, maxUnbrokenWordWidth));
+        }
+    }
+    let minColumnWidths = minWordWidths;
+    let minCellsWidth = minColumnWidths.reduce((a, b) => a + b, 0);
+    if (minCellsWidth > availableForCells) {
+        minColumnWidths = new Array(numCols).fill(1);
+        const remaining = availableForCells - numCols;
+        if (remaining > 0) {
+            const totalWeight = minWordWidths.reduce((total, width) => total + Math.max(0, width - 1), 0);
+            const growth = minWordWidths.map((width) => {
+                const weight = Math.max(0, width - 1);
+                return totalWeight > 0 ? Math.floor((weight / totalWeight) * remaining) : 0;
+            });
+            for (let i = 0; i < numCols; i++) {
+                minColumnWidths[i] += growth[i];
+            }
+            const allocated = growth.reduce((total, width) => total + width, 0);
+            let leftover = remaining - allocated;
+            for (let i = 0; leftover > 0 && i < numCols; i++) {
+                minColumnWidths[i]++;
+                leftover--;
+            }
+        }
+        minCellsWidth = minColumnWidths.reduce((a, b) => a + b, 0);
+    }
+    // Calculate column widths that fit within available width
+    const totalNaturalWidth = naturalWidths.reduce((a, b) => a + b, 0) + borderOverhead;
+    let columnWidths;
+    if (totalNaturalWidth <= availableWidth) {
+        // Everything fits naturally
+        columnWidths = naturalWidths.map((width, index) => Math.max(width, minColumnWidths[index]));
+    }
+    else {
+        // Need to shrink columns to fit
+        const totalGrowPotential = naturalWidths.reduce((total, width, index) => {
+            return total + Math.max(0, width - minColumnWidths[index]);
+        }, 0);
+        const extraWidth = Math.max(0, availableForCells - minCellsWidth);
+        columnWidths = minColumnWidths.map((minWidth, index) => {
+            const naturalWidth = naturalWidths[index];
+            const minWidthDelta = Math.max(0, naturalWidth - minWidth);
+            let grow = 0;
+            if (totalGrowPotential > 0) {
+                grow = Math.floor((minWidthDelta / totalGrowPotential) * extraWidth);
+            }
+            return minWidth + grow;
+        });
+        // Adjust for rounding errors - distribute remaining space
+        const allocated = columnWidths.reduce((a, b) => a + b, 0);
+        let remaining = availableForCells - allocated;
+        while (remaining > 0) {
+            let grew = false;
+            for (let i = 0; i < numCols && remaining > 0; i++) {
+                if (columnWidths[i] < naturalWidths[i]) {
+                    columnWidths[i]++;
+                    remaining--;
+                    grew = true;
+                }
+            }
+            if (!grew) {
+                break;
+            }
+        }
+    }
+    // Render top border
+    const topBorderCells = columnWidths.map((w) => "─".repeat(w));
+    lines.push(`┌─${topBorderCells.join("─┬─")}─┐`);
+    // Render header with wrapping
+    const headerCellLines = token.header.map((cell, i) => {
+        const text = context.renderInlineTokens(cell.tokens || []);
+        return wrapCellText(text, columnWidths[i]);
+    });
+    const headerLineCount = Math.max(...headerCellLines.map((c) => c.length));
+    for (let lineIdx = 0; lineIdx < headerLineCount; lineIdx++) {
+        const rowParts = headerCellLines.map((cellLines, colIdx) => {
+            const text = cellLines[lineIdx] || "";
+            const padded = text + " ".repeat(Math.max(0, columnWidths[colIdx] - visibleWidth(text)));
+            return context.theme.bold(padded);
+        });
+        lines.push(`│ ${rowParts.join(" │ ")} │`);
+    }
+    // Render separator
+    const separatorCells = columnWidths.map((w) => "─".repeat(w));
+    const separatorLine = `├─${separatorCells.join("─┼─")}─┤`;
+    lines.push(separatorLine);
+    // Render rows with wrapping
+    for (let rowIndex = 0; rowIndex < token.rows.length; rowIndex++) {
+        const row = token.rows[rowIndex];
+        const rowCellLines = row.map((cell, i) => {
+            const text = context.renderInlineTokens(cell.tokens || []);
+            return wrapCellText(text, columnWidths[i]);
+        });
+        const rowLineCount = Math.max(...rowCellLines.map((c) => c.length));
+        for (let lineIdx = 0; lineIdx < rowLineCount; lineIdx++) {
+            const rowParts = rowCellLines.map((cellLines, colIdx) => {
+                const text = cellLines[lineIdx] || "";
+                return text + " ".repeat(Math.max(0, columnWidths[colIdx] - visibleWidth(text)));
+            });
+            lines.push(`│ ${rowParts.join(" │ ")} │`);
+        }
+        if (rowIndex < token.rows.length - 1) {
+            lines.push(separatorLine);
+        }
+    }
+    // Render bottom border
+    const bottomBorderCells = columnWidths.map((w) => "─".repeat(w));
+    lines.push(`└─${bottomBorderCells.join("─┴─")}─┘`);
+    lines.push(""); // Add spacing after table
+    return lines;
+}

package/dist/components/markdown/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Type definitions for the Markdown component.
+ */
+/**
+ * Default text styling for markdown content.
+ * Applied to all text unless overridden by markdown formatting.
+ */
+export interface DefaultTextStyle {
+    /** Foreground color function */
+    color?: (text: string) => string;
+    /** Background color function */
+    bgColor?: (text: string) => string;
+    /** Bold text */
+    bold?: boolean;
+    /** Italic text */
+    italic?: boolean;
+    /** Strikethrough text */
+    strikethrough?: boolean;
+    /** Underline text */
+    underline?: boolean;
+}
+/**
+ * Theme functions for markdown elements.
+ * Each function takes text and returns styled text with ANSI codes.
+ */
+export interface MarkdownTheme {
+    heading: (text: string) => string;
+    link: (text: string) => string;
+    linkUrl: (text: string) => string;
+    code: (text: string) => string;
+    codeBlock: (text: string) => string;
+    codeBlockBorder: (text: string) => string;
+    quote: (text: string) => string;
+    quoteBorder: (text: string) => string;
+    hr: (text: string) => string;
+    listBullet: (text: string) => string;
+    bold: (text: string) => string;
+    italic: (text: string) => string;
+    strikethrough: (text: string) => string;
+    underline: (text: string) => string;
+    highlightCode?: (code: string, lang?: string) => string[];
+    /** Prefix applied to each rendered code block line (default: "  ") */
+    codeBlockIndent?: string;
+}
+/**
+ * Context for inline token rendering, carrying style functions and prefixes.
+ */
+export interface InlineStyleContext {
+    applyText: (text: string) => string;
+    stylePrefix: string;
+}
+/**
+ * Get the style prefix from a styling function.
+ * Uses a sentinel character to extract the ANSI prefix codes.
+ */
+export declare function getStylePrefix(styleFn: (text: string) => string): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/components/markdown/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/markdown/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAChC,gCAAgC;IAChC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACjC,gCAAgC;IAChC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACnC,gBAAgB;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,kBAAkB;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,yBAAyB;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qBAAqB;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC7B,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAClC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC/B,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAClC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC/B,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC1C,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAChC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACtC,EAAE,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC7B,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACrC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC/B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACjC,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACxC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;IAC1D,sEAAsE;IACtE,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,CAKxE"}

package/dist/components/markdown/types.js

@@ -0,0 +1,13 @@
+/**
+ * Type definitions for the Markdown component.
+ */
+/**
+ * Get the style prefix from a styling function.
+ * Uses a sentinel character to extract the ANSI prefix codes.
+ */
+export function getStylePrefix(styleFn) {
+    const sentinel = "\u0000";
+    const styled = styleFn(sentinel);
+    const sentinelIndex = styled.indexOf(sentinel);
+    return sentinelIndex >= 0 ? styled.slice(0, sentinelIndex) : "";
+}

package/dist/components/markdown.d.ts

@@ -0,0 +1,44 @@
+import type { Component } from "../tui.js";
+export type { DefaultTextStyle, InlineStyleContext, MarkdownTheme } from "./markdown/types.js";
+import type { DefaultTextStyle, MarkdownTheme } from "./markdown/types.js";
+export declare class Markdown implements Component {
+    private text;
+    private paddingX;
+    private paddingY;
+    private defaultTextStyle?;
+    private theme;
+    private defaultStylePrefix?;
+    private cachedText?;
+    private cachedWidth?;
+    private cachedLines?;
+    constructor(text: string, paddingX: number, paddingY: number, theme: MarkdownTheme, defaultTextStyle?: DefaultTextStyle);
+    setText(text: string): void;
+    invalidate(): void;
+    render(width: number): string[];
+    /**
+     * 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.
+     */
+    private applyDefaultStyle;
+    private getDefaultStylePrefix;
+    private getDefaultInlineStyleContext;
+    private renderToken;
+    /**
+     * Render inline tokens to styled text.
+     * Delegates to the extracted inline-renderer utility.
+     */
+    private renderInlineTokens;
+    /**
+     * Render a list with proper nesting support.
+     * Delegates to the extracted list-renderer utility.
+     */
+    private renderList;
+    /**
+     * Render a table with width-aware cell wrapping.
+     * Delegates to the extracted table-renderer utility.
+     */
+    private renderTable;
+}
+//# sourceMappingURL=markdown.d.ts.map

package/dist/components/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/components/markdown.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAe3C,YAAY,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAG/F,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAE3E,qBAAa,QAAS,YAAW,SAAS;IACzC,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,gBAAgB,CAAC,CAAmB;IAC5C,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,kBAAkB,CAAC,CAAS;IAGpC,OAAO,CAAC,UAAU,CAAC,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAC,CAAS;IAC7B,OAAO,CAAC,WAAW,CAAC,CAAW;gBAG9B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,aAAa,EACpB,gBAAgB,CAAC,EAAE,gBAAgB;IASpC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAK3B,UAAU,IAAI,IAAI;IAMlB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;IAwF/B;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IA6BzB,OAAO,CAAC,qBAAqB;IAoC7B,OAAO,CAAC,4BAA4B;IAOpC,OAAO,CAAC,WAAW;IA2HnB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAQ1B;;;OAGG;IACH,OAAO,CAAC,UAAU;IAQlB;;;OAGG;IACH,OAAO,CAAC,WAAW;CAOnB"}