wave-code 0.0.2

package/dist/hooks/useCommandSelector.js

@@ -0,0 +1,98 @@
+import { useState, useCallback } from "react";
+export const useCommandSelector = ({ onShowBashManager, onShowMcpManager, sendMessage, hasSlashCommand, }) => {
+    const [showCommandSelector, setShowCommandSelector] = useState(false);
+    const [slashPosition, setSlashPosition] = useState(-1);
+    const [commandSearchQuery, setCommandSearchQuery] = useState("");
+    const activateCommandSelector = useCallback((position) => {
+        setShowCommandSelector(true);
+        setSlashPosition(position);
+        setCommandSearchQuery("");
+    }, []);
+    const handleCommandInsert = useCallback((command, inputText, cursorPosition) => {
+        if (slashPosition >= 0) {
+            // Replace content from / to current cursor position with /command_name + space
+            const beforeSlash = inputText.substring(0, slashPosition);
+            const afterQuery = inputText.substring(cursorPosition);
+            const newInput = beforeSlash + `/${command} ` + afterQuery;
+            const newCursorPosition = beforeSlash.length + command.length + 2; // +2 for "/" and " "
+            setShowCommandSelector(false);
+            setSlashPosition(-1);
+            setCommandSearchQuery("");
+            return { newInput, newCursorPosition };
+        }
+        return { newInput: inputText, newCursorPosition: cursorPosition };
+    }, [slashPosition]);
+    const handleCommandSelect = useCallback((command, inputText, cursorPosition) => {
+        if (slashPosition >= 0) {
+            // Replace command part, keep other content
+            const beforeSlash = inputText.substring(0, slashPosition);
+            const afterQuery = inputText.substring(cursorPosition);
+            const newInput = beforeSlash + afterQuery;
+            const newCursorPosition = beforeSlash.length;
+            // Execute command asynchronously
+            (async () => {
+                // First check if it's an agent command
+                let commandExecuted = false;
+                if (sendMessage && hasSlashCommand && hasSlashCommand(command)) {
+                    // Execute complete command (replace partial input with complete command name)
+                    const fullCommand = `/${command}`;
+                    try {
+                        await sendMessage(fullCommand);
+                        commandExecuted = true;
+                    }
+                    catch (error) {
+                        console.error("Failed to execute slash command:", error);
+                    }
+                }
+                // If not an agent command or execution failed, check local commands
+                if (!commandExecuted) {
+                    if (command === "bashes" && onShowBashManager) {
+                        onShowBashManager();
+                        commandExecuted = true;
+                    }
+                    else if (command === "mcp" && onShowMcpManager) {
+                        onShowMcpManager();
+                        commandExecuted = true;
+                    }
+                }
+            })();
+            setShowCommandSelector(false);
+            setSlashPosition(-1);
+            setCommandSearchQuery("");
+            return { newInput, newCursorPosition };
+        }
+        return { newInput: inputText, newCursorPosition: cursorPosition };
+    }, [
+        slashPosition,
+        onShowBashManager,
+        onShowMcpManager,
+        sendMessage,
+        hasSlashCommand,
+    ]);
+    const handleCancelCommandSelect = useCallback(() => {
+        setShowCommandSelector(false);
+        setSlashPosition(-1);
+        setCommandSearchQuery("");
+    }, []);
+    const updateCommandSearchQuery = useCallback((query) => {
+        setCommandSearchQuery(query);
+    }, []);
+    const checkForSlashDeletion = useCallback((cursorPosition) => {
+        if (showCommandSelector && cursorPosition <= slashPosition) {
+            handleCancelCommandSelect();
+            return true;
+        }
+        return false;
+    }, [showCommandSelector, slashPosition, handleCancelCommandSelect]);
+    return {
+        showCommandSelector,
+        commandSearchQuery,
+        activateCommandSelector,
+        handleCommandSelect,
+        handleCommandInsert,
+        handleCancelCommandSelect,
+        updateCommandSearchQuery,
+        checkForSlashDeletion,
+        slashPosition,
+    };
+};

package/dist/hooks/useFileSelector.d.ts

@@ -0,0 +1,16 @@
+import { FileItem } from "../components/FileSelector.js";
+export declare const useFileSelector: () => {
+    showFileSelector: boolean;
+    filteredFiles: FileItem[];
+    searchQuery: string;
+    activateFileSelector: (position: number) => void;
+    handleFileSelect: (filePath: string, inputText: string, cursorPosition: number) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+    handleCancelFileSelect: () => void;
+    updateSearchQuery: (query: string) => void;
+    checkForAtDeletion: (cursorPosition: number) => boolean;
+    atPosition: number;
+};
+//# sourceMappingURL=useFileSelector.d.ts.map

package/dist/hooks/useFileSelector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFileSelector.d.ts","sourceRoot":"","sources":["../../src/hooks/useFileSelector.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAEzD,eAAO,MAAM,eAAe;;;;qCA2Jb,MAAM;iCAWN,MAAM,aAAa,MAAM,kBAAkB,MAAM;;;;;+BA2BhB,MAAM;yCAKjC,MAAM;;CAqB1B,CAAC"}

package/dist/hooks/useFileSelector.js

@@ -0,0 +1,174 @@
+import { useState, useCallback, useEffect, useRef } from "react";
+import { glob } from "glob";
+import { getGlobIgnorePatterns } from "wave-agent-sdk";
+import * as fs from "fs";
+import * as path from "path";
+export const useFileSelector = () => {
+    const [showFileSelector, setShowFileSelector] = useState(false);
+    const [atPosition, setAtPosition] = useState(-1);
+    const [searchQuery, setSearchQuery] = useState("");
+    const [filteredFiles, setFilteredFiles] = useState([]);
+    const debounceTimerRef = useRef(null);
+    // Check if path is a directory
+    const isDirectory = useCallback((filePath) => {
+        try {
+            const fullPath = path.isAbsolute(filePath)
+                ? filePath
+                : path.join(process.cwd(), filePath);
+            return fs.statSync(fullPath).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }, []);
+    // Convert string paths to FileItem objects
+    const convertToFileItems = useCallback((paths) => {
+        return paths.map((filePath) => ({
+            path: filePath,
+            type: isDirectory(filePath) ? "directory" : "file",
+        }));
+    }, [isDirectory]);
+    // Use glob to search files and directories
+    const searchFiles = useCallback(async (query) => {
+        try {
+            let files = [];
+            let directories = [];
+            const globOptions = {
+                ignore: getGlobIgnorePatterns(process.cwd()),
+                maxDepth: 10,
+                nocase: true, // Case insensitive
+                dot: true, // Include hidden files and directories
+                cwd: process.cwd(), // Specify search root directory
+            };
+            if (!query.trim()) {
+                // When query is empty, show some common file types and directories
+                const commonPatterns = [
+                    "**/*.ts",
+                    "**/*.tsx",
+                    "**/*.js",
+                    "**/*.jsx",
+                    "**/*.json",
+                ];
+                // Search files
+                const filePromises = commonPatterns.map((pattern) => glob(pattern, { ...globOptions, nodir: true }));
+                // Search directories (only search first level to avoid too many results)
+                const dirPromises = [glob("*/", { ...globOptions, maxDepth: 1 })];
+                const fileResults = await Promise.all(filePromises);
+                const dirResults = await Promise.all(dirPromises);
+                files = fileResults.flat();
+                directories = dirResults.flat().map((dir) => {
+                    // glob returns string type paths, remove trailing slash
+                    return String(dir).replace(/\/$/, "");
+                });
+            }
+            else {
+                // Build multiple glob patterns to support more flexible search
+                const filePatterns = [
+                    // Match files with filenames containing query
+                    `**/*${query}*`,
+                    // Match files with query in path (match directory names)
+                    `**/${query}*/**/*`,
+                ];
+                const dirPatterns = [
+                    // Match directory names containing query
+                    `**/*${query}*/`,
+                    // Match directories containing query in path
+                    `**/${query}*/`,
+                ];
+                // Search files
+                const filePromises = filePatterns.map((pattern) => glob(pattern, { ...globOptions, nodir: true }));
+                // Search directories
+                const dirPromises = dirPatterns.map((pattern) => glob(pattern, { ...globOptions, nodir: false }));
+                const fileResults = await Promise.all(filePromises);
+                const dirResults = await Promise.all(dirPromises);
+                files = fileResults.flat();
+                directories = dirResults.flat().map((dir) => {
+                    // glob returns string type paths, remove trailing slash
+                    return String(dir).replace(/\/$/, "");
+                });
+            }
+            // Deduplicate and merge files and directories
+            const uniqueFiles = Array.from(new Set(files));
+            const uniqueDirectories = Array.from(new Set(directories));
+            const allPaths = [...uniqueDirectories, ...uniqueFiles]; // Directories first
+            // Limit to maximum 10 results and convert to FileItem
+            const fileItems = convertToFileItems(allPaths.slice(0, 10));
+            setFilteredFiles(fileItems);
+        }
+        catch (error) {
+            console.error("Glob search error:", error);
+            setFilteredFiles([]);
+        }
+    }, [convertToFileItems]);
+    // Debounced search
+    const debouncedSearchFiles = useCallback((query) => {
+        // Clear previous timer
+        if (debounceTimerRef.current) {
+            clearTimeout(debounceTimerRef.current);
+        }
+        // Set new timer, support environment variable configuration
+        const debounceDelay = parseInt(process.env.FILE_SELECTOR_DEBOUNCE_MS || "300", 10);
+        debounceTimerRef.current = setTimeout(() => {
+            searchFiles(query);
+        }, debounceDelay);
+    }, [searchFiles]);
+    // Trigger debounced search when search query changes
+    useEffect(() => {
+        debouncedSearchFiles(searchQuery);
+        // Cleanup function: clear timer when component unmounts
+        return () => {
+            if (debounceTimerRef.current) {
+                clearTimeout(debounceTimerRef.current);
+            }
+        };
+    }, [searchQuery, debouncedSearchFiles]);
+    const activateFileSelector = useCallback((position) => {
+        setShowFileSelector(true);
+        setAtPosition(position);
+        setSearchQuery("");
+        // Immediately trigger search to display initial file list, without waiting for debounce
+        searchFiles("");
+    }, [searchFiles]);
+    const handleFileSelect = useCallback((filePath, inputText, cursorPosition) => {
+        if (atPosition >= 0) {
+            // Replace @ and search query with selected file path, remove @ symbol
+            const beforeAt = inputText.substring(0, atPosition);
+            const afterQuery = inputText.substring(cursorPosition);
+            const newInput = beforeAt + `${filePath} ` + afterQuery;
+            const newCursorPosition = beforeAt.length + filePath.length + 1;
+            setShowFileSelector(false);
+            setAtPosition(-1);
+            setSearchQuery("");
+            setFilteredFiles([]);
+            return { newInput, newCursorPosition };
+        }
+        return { newInput: inputText, newCursorPosition: cursorPosition };
+    }, [atPosition]);
+    const handleCancelFileSelect = useCallback(() => {
+        setShowFileSelector(false);
+        setAtPosition(-1);
+        setSearchQuery("");
+        setFilteredFiles([]);
+    }, []);
+    const updateSearchQuery = useCallback((query) => {
+        setSearchQuery(query);
+    }, []);
+    const checkForAtDeletion = useCallback((cursorPosition) => {
+        if (showFileSelector && cursorPosition <= atPosition) {
+            handleCancelFileSelect();
+            return true;
+        }
+        return false;
+    }, [showFileSelector, atPosition, handleCancelFileSelect]);
+    return {
+        showFileSelector,
+        filteredFiles,
+        searchQuery,
+        activateFileSelector,
+        handleFileSelect,
+        handleCancelFileSelect,
+        updateSearchQuery,
+        checkForAtDeletion,
+        atPosition,
+    };
+};

package/dist/hooks/useImageManager.d.ts

@@ -0,0 +1,13 @@
+export interface AttachedImage {
+    id: number;
+    path: string;
+    mimeType: string;
+}
+export declare const useImageManager: (insertTextAtCursor: (text: string) => void) => {
+    attachedImages: AttachedImage[];
+    addImage: (imagePath: string, mimeType: string) => AttachedImage;
+    removeImage: (imageId: number) => void;
+    clearImages: () => void;
+    handlePasteImage: () => Promise<boolean>;
+};
+//# sourceMappingURL=useImageManager.d.ts.map

package/dist/hooks/useImageManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useImageManager.d.ts","sourceRoot":"","sources":["../../src/hooks/useImageManager.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,eAAe,GAAI,oBAAoB,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI;;0BAK1D,MAAM,YAAY,MAAM;2BAaI,MAAM;;;CAoCjD,CAAC"}

package/dist/hooks/useImageManager.js

@@ -0,0 +1,46 @@
+import { useState, useCallback } from "react";
+import { readClipboardImage } from "../utils/clipboard.js";
+export const useImageManager = (insertTextAtCursor) => {
+    const [attachedImages, setAttachedImages] = useState([]);
+    const [imageIdCounter, setImageIdCounter] = useState(1);
+    const addImage = useCallback((imagePath, mimeType) => {
+        const newImage = {
+            id: imageIdCounter,
+            path: imagePath,
+            mimeType,
+        };
+        setAttachedImages((prev) => [...prev, newImage]);
+        setImageIdCounter((prev) => prev + 1);
+        return newImage;
+    }, [imageIdCounter]);
+    const removeImage = useCallback((imageId) => {
+        setAttachedImages((prev) => prev.filter((img) => img.id !== imageId));
+    }, []);
+    const clearImages = useCallback(() => {
+        setAttachedImages([]);
+    }, []);
+    const handlePasteImage = useCallback(async () => {
+        try {
+            const result = await readClipboardImage();
+            if (result.success && result.imagePath && result.mimeType) {
+                // Add image to manager
+                const attachedImage = addImage(result.imagePath, result.mimeType);
+                // Insert image placeholder at cursor position
+                insertTextAtCursor(`[Image #${attachedImage.id}]`);
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            console.warn("Failed to paste image from clipboard:", error);
+            return false;
+        }
+    }, [addImage, insertTextAtCursor]);
+    return {
+        attachedImages,
+        addImage,
+        removeImage,
+        clearImages,
+        handlePasteImage,
+    };
+};

package/dist/hooks/useInputHistory.d.ts

@@ -0,0 +1,11 @@
+export interface UseInputHistoryParams {
+    userInputHistory: string[];
+}
+export declare const useInputHistory: ({ userInputHistory, }: UseInputHistoryParams) => {
+    resetHistoryNavigation: () => void;
+    navigateHistory: (direction: "up" | "down", inputText: string) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+};
+//# sourceMappingURL=useInputHistory.d.ts.map

package/dist/hooks/useInputHistory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInputHistory.d.ts","sourceRoot":"","sources":["../../src/hooks/useInputHistory.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,qBAAqB;IACpC,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,eAAO,MAAM,eAAe,GAAI,uBAE7B,qBAAqB;;iCAYR,IAAI,GAAG,MAAM,aAAa,MAAM;;;;CAqD/C,CAAC"}

package/dist/hooks/useInputHistory.js

@@ -0,0 +1,64 @@
+import { useState, useCallback } from "react";
+export const useInputHistory = ({ userInputHistory, }) => {
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const [currentDraftText, setCurrentDraftText] = useState("");
+    // Reset history navigation state
+    const resetHistoryNavigation = useCallback(() => {
+        setHistoryIndex(-1);
+        setCurrentDraftText("");
+    }, []);
+    // Handle history navigation
+    const navigateHistory = useCallback((direction, inputText) => {
+        if (userInputHistory.length === 0)
+            return { newInput: inputText, newCursorPosition: inputText.length };
+        let newInput;
+        if (direction === "up") {
+            // Navigate up to earlier history records
+            if (historyIndex === -1) {
+                // First time pressing up key, save current input as draft
+                setCurrentDraftText(inputText);
+                const newIndex = userInputHistory.length - 1;
+                setHistoryIndex(newIndex);
+                newInput = userInputHistory[newIndex];
+            }
+            else if (historyIndex > 0) {
+                const newIndex = historyIndex - 1;
+                setHistoryIndex(newIndex);
+                newInput = userInputHistory[newIndex];
+            }
+            else {
+                newInput = inputText;
+            }
+        }
+        else {
+            // Navigate down to newer history records
+            if (historyIndex >= 0) {
+                if (historyIndex < userInputHistory.length - 1) {
+                    const newIndex = historyIndex + 1;
+                    setHistoryIndex(newIndex);
+                    newInput = userInputHistory[newIndex];
+                }
+                else {
+                    // Return to draft text
+                    setHistoryIndex(-1);
+                    newInput = currentDraftText;
+                }
+            }
+            else {
+                // Already in draft state, pressing down key again clears input box
+                if (inputText.trim() !== "") {
+                    setCurrentDraftText("");
+                    newInput = "";
+                }
+                else {
+                    newInput = inputText;
+                }
+            }
+        }
+        return { newInput, newCursorPosition: newInput.length };
+    }, [userInputHistory, historyIndex, currentDraftText]);
+    return {
+        resetHistoryNavigation,
+        navigateHistory,
+    };
+};

package/dist/hooks/useInputKeyboardHandler.d.ts

@@ -0,0 +1,83 @@
+interface KeyboardHandlerProps {
+    inputText: string;
+    setInputText: (text: string) => void;
+    cursorPosition: number;
+    setCursorPosition: (position: number) => void;
+    moveCursorLeft: () => void;
+    moveCursorRight: () => void;
+    moveCursorToStart: () => void;
+    moveCursorToEnd: () => void;
+    deleteCharAtCursor: () => void;
+    insertTextAtCursor: (text: string) => void;
+    clearInput: () => void;
+    resetHistoryNavigation: () => void;
+    navigateHistory: (direction: "up" | "down", inputText: string, activateBashMode?: () => void) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+    handlePasteImage: () => Promise<boolean>;
+    attachedImages: Array<{
+        id: number;
+        path: string;
+        mimeType: string;
+    }>;
+    clearImages: () => void;
+    showFileSelector: boolean;
+    activateFileSelector: (position: number) => void;
+    handleFileSelect: (filePath: string, inputText: string, cursorPosition: number) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+    handleCancelFileSelect: () => void;
+    updateSearchQuery: (query: string) => void;
+    checkForAtDeletion: (cursorPosition: number) => boolean;
+    atPosition: number;
+    showCommandSelector: boolean;
+    activateCommandSelector: (position: number) => void;
+    handleCommandSelect: (command: string, inputText: string, cursorPosition: number) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+    handleCommandInsert: (command: string, inputText: string, cursorPosition: number) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+    handleCancelCommandSelect: () => void;
+    updateCommandSearchQuery: (query: string) => void;
+    checkForSlashDeletion: (cursorPosition: number) => boolean;
+    slashPosition: number;
+    showBashHistorySelector: boolean;
+    activateBashHistorySelector: (position: number) => void;
+    handleBashHistorySelect: (command: string, inputText: string, cursorPosition: number) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+    handleBashHistoryExecute: (command: string) => string;
+    handleCancelBashHistorySelect: () => void;
+    updateBashHistorySearchQuery: (query: string) => void;
+    checkForExclamationDeletion: (cursorPosition: number) => boolean;
+    exclamationPosition: number;
+    showMemoryTypeSelector: boolean;
+    activateMemoryTypeSelector: (message: string) => void;
+    handleMemoryTypeSelect: (type: "project" | "user") => void;
+    showBashManager: boolean;
+    showMcpManager: boolean;
+    isCommandRunning: boolean;
+    isLoading: boolean;
+    sendMessage: (message: string, images?: Array<{
+        path: string;
+        mimeType: string;
+    }>) => void;
+    abortMessage: () => void;
+    saveMemory: (message: string, type: "project" | "user") => Promise<void>;
+}
+export declare const useInputKeyboardHandler: (props: KeyboardHandlerProps) => {
+    handleFileSelect: (filePath: string) => void;
+    handleCommandSelect: (command: string) => void;
+    handleCommandInsert: (command: string) => void;
+    handleBashHistorySelect: (command: string) => void;
+    handleBashHistoryExecute: (command: string) => void;
+    handleMemoryTypeSelect: (type: "project" | "user") => Promise<void>;
+};
+export {};
+//# sourceMappingURL=useInputKeyboardHandler.d.ts.map

package/dist/hooks/useInputKeyboardHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInputKeyboardHandler.d.ts","sourceRoot":"","sources":["../../src/hooks/useInputKeyboardHandler.ts"],"names":[],"mappings":"AAIA,UAAU,oBAAoB;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,iBAAiB,EAAE,MAAM,IAAI,CAAC;IAC9B,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,kBAAkB,EAAE,MAAM,IAAI,CAAC;IAC/B,kBAAkB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,sBAAsB,EAAE,MAAM,IAAI,CAAC;IACnC,eAAe,EAAE,CACf,SAAS,EAAE,IAAI,GAAG,MAAM,EACxB,SAAS,EAAE,MAAM,EACjB,gBAAgB,CAAC,EAAE,MAAM,IAAI,KAC1B;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAE,CAAC;IACrD,gBAAgB,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IACzC,cAAc,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtE,WAAW,EAAE,MAAM,IAAI,CAAC;IAGxB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,oBAAoB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,gBAAgB,EAAE,CAChB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,KACnB;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAE,CAAC;IACrD,sBAAsB,EAAE,MAAM,IAAI,CAAC;IACnC,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,kBAAkB,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC;IACxD,UAAU,EAAE,MAAM,CAAC;IAGnB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,uBAAuB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACpD,mBAAmB,EAAE,CACnB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,KACnB;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAE,CAAC;IACrD,mBAAmB,EAAE,CACnB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,KACnB;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAE,CAAC;IACrD,yBAAyB,EAAE,MAAM,IAAI,CAAC;IACtC,wBAAwB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClD,qBAAqB,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC;IAC3D,aAAa,EAAE,MAAM,CAAC;IAGtB,uBAAuB,EAAE,OAAO,CAAC;IACjC,2BAA2B,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACxD,uBAAuB,EAAE,CACvB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,KACnB;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAE,CAAC;IACrD,wBAAwB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IACtD,6BAA6B,EAAE,MAAM,IAAI,CAAC;IAC1C,4BAA4B,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACtD,2BAA2B,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC;IACjE,mBAAmB,EAAE,MAAM,CAAC;IAG5B,sBAAsB,EAAE,OAAO,CAAC;IAChC,0BAA0B,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACtD,sBAAsB,EAAE,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,KAAK,IAAI,CAAC;IAG3D,eAAe,EAAE,OAAO,CAAC;IAGzB,cAAc,EAAE,OAAO,CAAC;IAGxB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,CACX,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,KAC/C,IAAI,CAAC;IACV,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1E;AAED,eAAO,MAAM,uBAAuB,GAAI,OAAO,oBAAoB;iCAqkBlD,MAAM;mCAmBP,MAAM;mCAmBN,MAAM;uCAmBN,MAAM;wCAmBN,MAAM;mCAcH,SAAS,GAAG,MAAM;CAapC,CAAC"}