@travisennis/acai 0.0.5 → 0.0.6

package/dist/tui/components/modal.js

@@ -0,0 +1,292 @@
+import { getTerminalSize } from "../../terminal/formatting.js";
+import { table } from "../../terminal/index.js";
+import style from "../../terminal/style.js";
+import { Container } from "../tui.js";
+import { visibleWidth } from "../utils.js";
+/**
+ * Modal component - displays content in an overlay on top of the main UI
+ */
+export class Modal extends Container {
+    title;
+    backdrop;
+    onClose;
+    maxWidth;
+    maxHeight;
+    scrollPosition = 0;
+    constructor(title, content, backdrop = true, onClose, maxWidth, maxHeight) {
+        super();
+        this.title = title;
+        this.backdrop = backdrop;
+        this.onClose = onClose;
+        const { columns, rows } = getTerminalSize();
+        this.maxWidth = maxWidth ?? columns;
+        this.maxHeight = maxHeight ?? rows;
+        this.addChild(content);
+    }
+    handleInput(data) {
+        // Handle Escape key to close modal
+        if (data === "\x1b") {
+            this.close();
+            return;
+        }
+        // Handle scrolling
+        if (data === "\x1b[A") {
+            // Up arrow
+            this.scrollPosition = Math.max(0, this.scrollPosition - 1);
+            return;
+        }
+        if (data === "\x1b[B") {
+            // Down arrow
+            this.scrollPosition += 1;
+            return;
+        }
+        if (data === "\x1b[5~") {
+            // Page up
+            this.scrollPosition = Math.max(0, this.scrollPosition - 10);
+            return;
+        }
+        if (data === "\x1b[6~") {
+            // Page down
+            this.scrollPosition += 10;
+            return;
+        }
+        if (data === "\x1b[H" || data === "g") {
+            // Home key or 'g' for top
+            this.scrollPosition = 0;
+            return;
+        }
+        if (data === "\x1b[F" || data === "G") {
+            // End key or 'G' for bottom
+            this.scrollPosition = Number.POSITIVE_INFINITY; // Will be clamped in render
+            return;
+        }
+        // Pass input to focused child component
+        if (this.children.length > 0) {
+            const focusedChild = this.children[0];
+            if (focusedChild.handleInput) {
+                focusedChild.handleInput(data);
+            }
+        }
+    }
+    close() {
+        if (this.onClose) {
+            this.onClose();
+        }
+    }
+    render(width) {
+        const lines = [];
+        // Calculate modal dimensions - use dynamic sizing
+        // Use the provided width directly, ensuring reasonable minimum and maximum
+        const modalWidth = Math.max(40, width - 2);
+        const contentWidth = modalWidth - 4; // Account for borders and padding
+        // Calculate content height
+        const contentLines = super.render(contentWidth);
+        const contentHeight = contentLines.length;
+        // Calculate modal height based on content
+        const modalHeight = Math.min(this.maxHeight, Math.max(8, contentHeight + 4));
+        // Calculate vertical positioning (centered)
+        const { rows } = getTerminalSize();
+        const terminalHeight = rows;
+        const topOffset = Math.max(0, Math.floor((terminalHeight - modalHeight) / 2));
+        // Add top offset for centering
+        for (let i = 0; i < topOffset; i++) {
+            lines.push(" ".repeat(width));
+        }
+        // Render modal frame
+        const horizontalBorder = style.white("─".repeat(modalWidth - 2));
+        const emptyLine = style.white("│") + " ".repeat(modalWidth - 2) + style.white("│");
+        // Calculate horizontal offset for centering
+        // Use different offsets for left and right to ensure full width coverage
+        const leftOffset = Math.floor((width - modalWidth) / 2);
+        const rightOffset = width - modalWidth - leftOffset;
+        // Top border
+        lines.push(" ".repeat(leftOffset) +
+            style.white("┌") +
+            horizontalBorder +
+            style.white("┐") +
+            " ".repeat(rightOffset));
+        // Render content lines with scrolling support
+        const visibleContentHeight = Math.min(contentHeight, modalHeight - 4);
+        const maxScroll = Math.max(0, contentHeight - visibleContentHeight);
+        // Clamp scroll position
+        this.scrollPosition = Math.min(maxScroll, Math.max(0, this.scrollPosition));
+        // Add scroll indicator to title if content is scrollable
+        let displayTitle = this.title;
+        if (contentHeight > visibleContentHeight) {
+            const scrollInfo = ` (${this.scrollPosition + 1}-${Math.min(this.scrollPosition + visibleContentHeight, contentHeight)}/${contentHeight})`;
+            displayTitle = this.title + scrollInfo;
+        }
+        displayTitle += " [esc to exit]";
+        // Update title line with scroll info
+        const titleText = ` ${displayTitle} `;
+        const titlePadding = Math.max(0, modalWidth - 2 - visibleWidth(titleText));
+        const titleLine = style.white("│") +
+            style.bold(titleText) +
+            " ".repeat(titlePadding) +
+            style.white("│");
+        lines.push(" ".repeat(leftOffset) + titleLine + " ".repeat(rightOffset));
+        // Separator line
+        const separator = style.white("├") + "─".repeat(modalWidth - 2) + style.white("┤");
+        lines.push(" ".repeat(leftOffset) + separator + " ".repeat(rightOffset));
+        for (let i = 0; i < visibleContentHeight; i++) {
+            const contentLineIndex = this.scrollPosition + i;
+            const contentLine = contentLines[contentLineIndex] || "";
+            const visibleLength = visibleWidth(contentLine);
+            const padding = " ".repeat(Math.max(0, contentWidth - visibleLength));
+            const line = `${style.white("│")} ${contentLine}${padding} ${style.white("│")}`;
+            lines.push(" ".repeat(leftOffset) + line + " ".repeat(rightOffset));
+        }
+        // Fill remaining content area with empty lines if needed
+        const remainingLines = modalHeight - 4 - visibleContentHeight;
+        for (let i = 0; i < remainingLines; i++) {
+            lines.push(" ".repeat(leftOffset) + emptyLine + " ".repeat(rightOffset));
+        }
+        // Bottom border
+        lines.push(" ".repeat(leftOffset) +
+            style.white("└") +
+            horizontalBorder +
+            style.white("┘") +
+            " ".repeat(rightOffset));
+        // Fill remaining terminal height with empty lines
+        const totalLinesSoFar = lines.length;
+        const remainingTerminalLines = Math.max(0, terminalHeight - totalLinesSoFar);
+        for (let i = 0; i < remainingTerminalLines; i++) {
+            lines.push(" ".repeat(width));
+        }
+        return lines;
+    }
+    getCursorPosition() {
+        // Modal doesn't have its own cursor, but children might
+        if (this.children.length > 0) {
+            const childCursor = this.children[0].getCursorPosition?.();
+            if (childCursor) {
+                // Adjust cursor position for modal frame and centering
+                const [childRow, childCol] = childCursor;
+                const modalWidth = Math.min(this.maxWidth, 80 - 4);
+                const horizontalOffset = Math.floor((80 - modalWidth) / 2);
+                // Top padding + title + separator + content offset
+                const { columns } = getTerminalSize();
+                const terminalHeight = columns;
+                const modalHeight = Math.min(this.maxHeight, terminalHeight - 4);
+                const topPadding = Math.max(0, Math.floor((terminalHeight - modalHeight) / 2));
+                return [
+                    topPadding + 3 + childRow, // 3 = top border + title + separator
+                    horizontalOffset + 2 + childCol, // 2 = left border + padding
+                ];
+            }
+        }
+        return null;
+    }
+}
+/**
+ * ModalText component - displays text content in a modal with word wrapping
+ */
+export class ModalText extends Container {
+    text;
+    paddingX;
+    paddingY;
+    constructor(text, paddingX = 1, paddingY = 0) {
+        super();
+        this.text = text;
+        this.paddingX = paddingX;
+        this.paddingY = paddingY;
+    }
+    render(width) {
+        const lines = [];
+        const contentWidth = Math.max(1, width - this.paddingX * 2);
+        if (!this.text || this.text.trim() === "") {
+            return [];
+        }
+        // Replace tabs with spaces
+        const normalizedText = this.text.replace(/\t/g, "   ");
+        const textLines = normalizedText.split("\n");
+        for (const line of textLines) {
+            const visibleLineLength = visibleWidth(line);
+            if (visibleLineLength <= contentWidth) {
+                lines.push(line);
+            }
+            else {
+                // Word wrap
+                const words = line.split(" ");
+                let currentLine = "";
+                for (const word of words) {
+                    const currentVisible = visibleWidth(currentLine);
+                    const wordVisible = visibleWidth(word);
+                    let finalWord = word;
+                    if (wordVisible > contentWidth) {
+                        // Truncate word to fit
+                        let truncated = "";
+                        for (const char of word) {
+                            if (visibleWidth(truncated + char) > contentWidth) {
+                                break;
+                            }
+                            truncated += char;
+                        }
+                        finalWord = truncated;
+                    }
+                    if (currentVisible === 0) {
+                        currentLine = finalWord;
+                    }
+                    else if (currentVisible + 1 + visibleWidth(finalWord) <=
+                        contentWidth) {
+                        currentLine += ` ${finalWord}`;
+                    }
+                    else {
+                        lines.push(currentLine);
+                        currentLine = finalWord;
+                    }
+                }
+                if (currentLine.length > 0) {
+                    lines.push(currentLine);
+                }
+            }
+        }
+        // Add padding
+        const leftPad = " ".repeat(this.paddingX);
+        const paddedLines = [];
+        // Top padding
+        for (let i = 0; i < this.paddingY; i++) {
+            paddedLines.push("");
+        }
+        // Content with horizontal padding
+        for (const line of lines) {
+            const visibleLength = visibleWidth(line);
+            const rightPadLength = Math.max(0, width - this.paddingX - visibleLength);
+            const rightPad = " ".repeat(rightPadLength);
+            paddedLines.push(leftPad + line + rightPad);
+        }
+        // Bottom padding
+        for (let i = 0; i < this.paddingY; i++) {
+            paddedLines.push("");
+        }
+        return paddedLines;
+    }
+}
+/**
+ * ModalTable component - displays tabular data in a modal
+ * Uses the terminal table function for proper text wrapping and formatting
+ */
+export class ModalTable extends Container {
+    data;
+    headers;
+    colWidths;
+    constructor(data, headers, colWidths) {
+        super();
+        this.data = data;
+        this.headers = headers;
+        this.colWidths = colWidths;
+    }
+    render(width) {
+        if (this.data.length === 0) {
+            return [];
+        }
+        // Use the terminal table function for proper text wrapping and formatting
+        const tableString = table(this.data, {
+            header: this.headers,
+            colWidths: this.colWidths,
+            width: width,
+        });
+        // Split the table string into lines and return
+        return tableString.split("\n");
+    }
+}

package/dist/tui/components/prompt-status.d.ts

@@ -0,0 +1,16 @@
+import type { ModelManager } from "../../models/manager.ts";
+import type { Component } from "../index.ts";
+type State = {
+    projectStatus: string;
+    currentContextWindow: number;
+    contextWindow: number;
+};
+export declare class PromptStatusComponent implements Component {
+    private modelManager;
+    private state;
+    constructor(modelManager: ModelManager, state: State);
+    setState(state: State): void;
+    render(width: number): string[];
+}
+export {};
+//# sourceMappingURL=prompt-status.d.ts.map

package/dist/tui/components/prompt-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-status.d.ts","sourceRoot":"","sources":["../../../source/tui/components/prompt-status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAG5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,KAAK,KAAK,GAAG;IACX,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,qBAAa,qBAAsB,YAAW,SAAS;IACrD,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,KAAK,CAAQ;gBACT,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK;IAKpD,QAAQ,CAAC,KAAK,EAAE,KAAK;IAIrB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;CAkBhC"}

package/dist/tui/components/prompt-status.js

@@ -0,0 +1,21 @@
+import { displayProgressBar } from "../../terminal/index.js";
+import style from "../../terminal/style.js";
+export class PromptStatusComponent {
+    modelManager;
+    state;
+    constructor(modelManager, state) {
+        this.modelManager = modelManager;
+        this.state = state;
+    }
+    setState(state) {
+        this.state = state;
+    }
+    render(width) {
+        const results = [];
+        // results.push(style.dim(hr(width)));
+        results.push(this.state.projectStatus);
+        results.push(style.dim(`${this.modelManager.getModelMetadata("repl").id} [${this.modelManager.getModel("repl").modelId}]`));
+        results.push(displayProgressBar(this.state.currentContextWindow, this.state.contextWindow, width));
+        return results;
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"select-list.d.ts","sourceRoot":"","sources":["../../../source/tui/components/select-list.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,UAAW,YAAW,SAAS;IAC1C,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,aAAa,CAAoB;IACzC,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,UAAU,CAAK;IAEhB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;gBAEjB,KAAK,EAAE,UAAU,EAAE,EAAE,UAAU,SAAI;IAM/C,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE;IAK/B,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAQ/B,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAOrC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;IA8G/B,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IA2BlC,eAAe,IAAI,UAAU,GAAG,IAAI;CAIrC"}

package/dist/tui/components/select-list.js

@@ -0,0 +1,143 @@
+import style from "../../terminal/style.js";
+export class SelectList {
+    items = [];
+    filteredItems = [];
+    selectedIndex = 0;
+    maxVisible = 5;
+    onSelect;
+    onCancel;
+    constructor(items, maxVisible = 5) {
+        this.items = items;
+        this.filteredItems = items;
+        this.maxVisible = maxVisible;
+    }
+    updateItems(items) {
+        this.items = items;
+        this.filteredItems = items;
+    }
+    setFilter(filter) {
+        this.filteredItems = this.items.filter((item) => item.value.toLowerCase().startsWith(filter.toLowerCase()));
+        // Reset selection when filter changes
+        this.selectedIndex = 0;
+    }
+    setSelectedIndex(index) {
+        this.selectedIndex = Math.max(0, Math.min(index, this.filteredItems.length - 1));
+    }
+    render(width) {
+        const lines = [];
+        // If no items match filter, show message
+        if (this.filteredItems.length === 0) {
+            lines.push(style.gray("  No matching commands"));
+            return lines;
+        }
+        // Calculate visible range with scrolling
+        const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.filteredItems.length - this.maxVisible));
+        const endIndex = Math.min(startIndex + this.maxVisible, this.filteredItems.length);
+        // Render visible items
+        for (let i = startIndex; i < endIndex; i++) {
+            const item = this.filteredItems[i];
+            if (!item)
+                continue;
+            const isSelected = i === this.selectedIndex;
+            let line = "";
+            if (isSelected) {
+                // Use arrow indicator for selection
+                const prefix = style.blue("→ ");
+                const prefixWidth = 2; // "→ " is 2 characters visually
+                const displayValue = item.label || item.value;
+                if (item.description && width > 40) {
+                    // Calculate how much space we have for value + description
+                    const maxValueLength = Math.min(displayValue.length, 30);
+                    const truncatedValue = displayValue.substring(0, maxValueLength);
+                    const spacing = " ".repeat(Math.max(1, 32 - truncatedValue.length));
+                    // Calculate remaining space for description using visible widths
+                    const descriptionStart = prefixWidth + truncatedValue.length + spacing.length;
+                    const remainingWidth = width - descriptionStart - 2; // -2 for safety
+                    if (remainingWidth > 10) {
+                        const truncatedDesc = item.description.substring(0, remainingWidth);
+                        line =
+                            prefix +
+                                style.blue(truncatedValue) +
+                                style.gray(spacing + truncatedDesc);
+                    }
+                    else {
+                        // Not enough space for description
+                        const maxWidth = width - prefixWidth - 2;
+                        line = prefix + style.blue(displayValue.substring(0, maxWidth));
+                    }
+                }
+                else {
+                    // No description or not enough width
+                    const maxWidth = width - prefixWidth - 2;
+                    line = prefix + style.blue(displayValue.substring(0, maxWidth));
+                }
+            }
+            else {
+                const displayValue = item.label || item.value;
+                const prefix = "  ";
+                if (item.description && width > 40) {
+                    // Calculate how much space we have for value + description
+                    const maxValueLength = Math.min(displayValue.length, 30);
+                    const truncatedValue = displayValue.substring(0, maxValueLength);
+                    const spacing = " ".repeat(Math.max(1, 32 - truncatedValue.length));
+                    // Calculate remaining space for description
+                    const descriptionStart = prefix.length + truncatedValue.length + spacing.length;
+                    const remainingWidth = width - descriptionStart - 2; // -2 for safety
+                    if (remainingWidth > 10) {
+                        const truncatedDesc = item.description.substring(0, remainingWidth);
+                        line =
+                            prefix + truncatedValue + style.gray(spacing + truncatedDesc);
+                    }
+                    else {
+                        // Not enough space for description
+                        const maxWidth = width - prefix.length - 2;
+                        line = prefix + displayValue.substring(0, maxWidth);
+                    }
+                }
+                else {
+                    // No description or not enough width
+                    const maxWidth = width - prefix.length - 2;
+                    line = prefix + displayValue.substring(0, maxWidth);
+                }
+            }
+            lines.push(line);
+        }
+        // Add scroll indicators if needed
+        if (startIndex > 0 || endIndex < this.filteredItems.length) {
+            const scrollText = `  (${this.selectedIndex + 1}/${this.filteredItems.length})`;
+            // Truncate if too long for terminal
+            const maxWidth = width - 2;
+            const truncated = scrollText.substring(0, maxWidth);
+            const scrollInfo = style.gray(truncated);
+            lines.push(scrollInfo);
+        }
+        return lines;
+    }
+    handleInput(keyData) {
+        // Up arrow
+        if (keyData === "\x1b[A") {
+            this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+        }
+        // Down arrow or Tab
+        else if (keyData === "\x1b[B" || keyData === "\t") {
+            this.selectedIndex = Math.min(this.filteredItems.length - 1, this.selectedIndex + 1);
+        }
+        // Enter
+        else if (keyData === "\r") {
+            const selectedItem = this.filteredItems[this.selectedIndex];
+            if (selectedItem && this.onSelect) {
+                this.onSelect(selectedItem);
+            }
+        }
+        // Escape or Ctrl+C
+        else if (keyData === "\x1b" || keyData === "\x03") {
+            if (this.onCancel) {
+                this.onCancel();
+            }
+        }
+    }
+    getSelectedItem() {
+        const item = this.filteredItems[this.selectedIndex];
+        return item || null;
+    }
+}

package/dist/tui/components/spacer.d.ts

@@ -0,0 +1,16 @@
+import type { Component } from "../tui.ts";
+/**
+ * Spacer component that renders empty lines
+ */
+export declare class Spacer implements Component {
+    private lines;
+    private customBgRgb?;
+    constructor(lines?: number, customBgRgb?: {
+        r: number;
+        g: number;
+        b: number;
+    });
+    setLines(lines: number): void;
+    render(_width: number): string[];
+}
+//# sourceMappingURL=spacer.d.ts.map

package/dist/tui/components/spacer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spacer.d.ts","sourceRoot":"","sources":["../../../source/tui/components/spacer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C;;GAEG;AACH,qBAAa,MAAO,YAAW,SAAS;IACtC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,WAAW,CAAC,CAAsC;gBAE9C,KAAK,SAAI,EAAE,WAAW,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE;IAKxE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI7B,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;CAgBjC"}

package/dist/tui/components/spacer.js

@@ -0,0 +1,27 @@
+import style from "../../terminal/style.js";
+/**
+ * Spacer component that renders empty lines
+ */
+export class Spacer {
+    lines;
+    customBgRgb;
+    constructor(lines = 1, customBgRgb) {
+        this.lines = lines;
+        this.customBgRgb = customBgRgb;
+    }
+    setLines(lines) {
+        this.lines = lines;
+    }
+    render(_width) {
+        const result = [];
+        for (let i = 0; i < this.lines; i++) {
+            let line = "";
+            // Apply background color if specified
+            if (this.customBgRgb) {
+                line = style.bgRgb(this.customBgRgb.r, this.customBgRgb.g, this.customBgRgb.b)(line);
+            }
+            result.push(line);
+        }
+        return result;
+    }
+}

package/dist/tui/components/text.d.ts

@@ -0,0 +1,26 @@
+import type { Component } from "../tui.ts";
+/**
+ * Text component - displays multi-line text with word wrapping
+ */
+export declare class Text implements Component {
+    private text;
+    private paddingX;
+    private paddingY;
+    private customBgRgb?;
+    private cachedText?;
+    private cachedWidth?;
+    private cachedLines?;
+    constructor(text?: string, paddingX?: number, paddingY?: number, customBgRgb?: {
+        r: number;
+        g: number;
+        b: number;
+    });
+    setText(text: string): void;
+    setCustomBgRgb(customBgRgb?: {
+        r: number;
+        g: number;
+        b: number;
+    }): void;
+    render(width: number): string[];
+}
+//# sourceMappingURL=text.d.ts.map

package/dist/tui/components/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../source/tui/components/text.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAG3C;;GAEG;AACH,qBAAa,IAAK,YAAW,SAAS;IACpC,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,WAAW,CAAC,CAAsC;IAG1D,OAAO,CAAC,UAAU,CAAC,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAC,CAAS;IAC7B,OAAO,CAAC,WAAW,CAAC,CAAW;gBAG7B,IAAI,SAAK,EACT,QAAQ,SAAI,EACZ,QAAQ,SAAI,EACZ,WAAW,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE;IAQnD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQ3B,cAAc,CAAC,WAAW,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAQvE,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;CA4IhC"}