@travisennis/acai 0.0.11 → 0.0.13

package/dist/tools/directory-tree.js

@@ -1,152 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { z } from "zod";
-import style from "../terminal/style.js";
-import { toDisplayPath } from "../utils/filesystem/path-display.js";
-import { joinWorkingDir, validatePath } from "../utils/filesystem/security.js";
-import ignore from "../utils/ignore.js";
-import { convertNullString } from "../utils/zod.js";
-const DEFAULT_ITEM_LIMIT = 500;
-const DEFAULT_DEPTH_LIMIT = 10;
-export const DirectoryTreeTool = {
-    name: "DirectoryTree",
-};
-const inputSchema = z.object({
-    path: z.string().describe("The path"),
-    maxResults: z
-        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
-        .describe(`Maximum number of items (files + directories) to return. Set to 0 for no limit. (default: ${DEFAULT_ITEM_LIMIT})`),
-    maxDepth: z
-        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
-        .describe(`Maximum recursion depth. Set to 0 for no limit. (default: ${DEFAULT_DEPTH_LIMIT})`),
-});
-export const createDirectoryTreeTool = async (options) => {
-    const { primaryDir, allowedDirs } = options.workspace;
-    const allowedDirectory = allowedDirs ?? [primaryDir];
-    return {
-        toolDef: {
-            description: "Show directory structure as a recursive tree. Use this to explore nested directories and understand the overall project structure. For a simple flat list of a single directory, use LS instead.",
-            inputSchema,
-        },
-        display({ path, maxDepth, maxResults }) {
-            const displayPath = toDisplayPath(path);
-            let display = `${style.cyan(displayPath)}`;
-            if (maxDepth || maxResults) {
-                const parts = [];
-                if (maxDepth)
-                    parts.push(`depth: ${maxDepth}`);
-                if (maxResults)
-                    parts.push(`max: ${maxResults}`);
-                display += ` (${parts.join(", ")})`;
-            }
-            return display;
-        },
-        async execute({ path, maxResults, maxDepth }, { abortSignal }) {
-            if (abortSignal?.aborted) {
-                throw new Error("Directory tree listing aborted");
-            }
-            const validPath = await validatePath(joinWorkingDir(path, primaryDir), allowedDirectory, { abortSignal });
-            if (abortSignal?.aborted) {
-                throw new Error("Directory tree listing aborted before tree generation");
-            }
-            const treeResult = await directoryTree(validPath, {
-                maxResults: maxResults ?? DEFAULT_ITEM_LIMIT,
-                maxDepth: maxDepth ?? DEFAULT_DEPTH_LIMIT,
-            });
-            return treeResult.tree;
-        },
-    };
-};
-/**
- * Generates the indentation string for a given level in the directory tree.
- * @param level - The current level in the directory tree.
- * @param isLast - Indicates if the current item is the last in its parent directory.
- * @returns The indentation string for the current level.
- */
-function getIndent(level, isLast) {
-    const indent = "│   ".repeat(Math.max(level - 1, 0));
-    return level === 0 ? "" : `${indent}${isLast ? "└── " : "├── "}`;
-}
-/**
- * Recursively generates a string representation of a directory tree.
- * @param dirPath - The path of the directory to generate the tree for.
- * @param ig - The ignore instance for filtering files.
- * @param level - The current level in the directory tree (default: 0).
- * @param options - Options for limiting results.
- * @returns A Promise that resolves to a string representation of the directory tree with counts.
- * @throws Will log an error if there's an issue reading the directory.
- */
-async function generateDirectoryTree(dirPath, ig, level = 0, options = {}) {
-    const name = path.basename(dirPath);
-    let output = `${getIndent(level, false)}${name}\n`;
-    let fileCount = 0;
-    let directoryCount = 1; // Count the current directory
-    let totalCount = 1; // Count the current directory
-    let isTruncated = false;
-    // Check maxDepth limit - when maxDepth is reached, we should indicate truncation
-    if (options.maxDepth !== null &&
-        options.maxDepth !== undefined &&
-        options.maxDepth > 0 &&
-        level >= options.maxDepth) {
-        // When maxDepth is reached, return with truncation flag set
-        return {
-            tree: output,
-            fileCount: 0,
-            directoryCount: 1, // Count the current directory
-            totalCount: 1, // Count the current directory
-            isTruncated: true, // Set truncation flag when depth limit is reached
-        };
-    }
-    const items = await fs.readdir(dirPath);
-    const filteredItems = ig.filter(items);
-    for (let i = 0; i < filteredItems.length; i++) {
-        // Check maxResults limit BEFORE processing each item to ensure strict adherence to limits
-        if (options.maxResults !== null &&
-            options.maxResults !== undefined &&
-            options.maxResults > 0 &&
-            totalCount >= options.maxResults) {
-            isTruncated = true;
-            break;
-        }
-        const item = filteredItems[i] ?? "";
-        const itemPath = path.join(dirPath, item);
-        const isLast = i === filteredItems.length - 1;
-        const stats = await fs.stat(itemPath);
-        if (stats.isDirectory()) {
-            const subTreeResult = await generateDirectoryTree(itemPath, ig, level + 1, options);
-            output += subTreeResult.tree;
-            fileCount += subTreeResult.fileCount;
-            directoryCount += subTreeResult.directoryCount;
-            totalCount += subTreeResult.totalCount;
-            // Propagate truncation from subtree results
-            if (subTreeResult.isTruncated) {
-                isTruncated = true;
-            }
-        }
-        else {
-            output += `${getIndent(level + 1, isLast)}${item}\n`;
-            fileCount += 1;
-            totalCount += 1;
-        }
-    }
-    return { tree: output, fileCount, directoryCount, totalCount, isTruncated };
-}
-async function directoryTree(dirPath, options = {}) {
-    let ig;
-    try {
-        const ignoreFile = await fs.readFile(path.join(process.cwd(), ".gitignore"));
-        ig = ignore().add(ignoreFile.toString()).add(".git");
-    }
-    catch (_error) {
-        // If .gitignore doesn't exist, create basic ignore with just .git
-        ig = ignore().add(".git");
-    }
-    const result = await generateDirectoryTree(dirPath, ig, 0, options);
-    return {
-        tree: result.tree.trim(),
-        fileCount: result.fileCount,
-        directoryCount: result.directoryCount,
-        totalCount: result.totalCount,
-        isTruncated: result.isTruncated,
-    };
-}

package/dist/tools/glob.d.ts

@@ -1,35 +0,0 @@
-import { z } from "zod";
-import type { ToolExecutionOptions } from "./types.ts";
-export declare const GlobTool: {
-    name: "Glob";
-};
-export declare const inputSchema: z.ZodObject<{
-    patterns: z.ZodPipe<z.ZodTransform<{}, unknown>, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    path: z.ZodPipe<z.ZodTransform<{}, unknown>, z.ZodString>;
-    gitignore: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    expandDirectories: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    ignoreFiles: z.ZodPipe<z.ZodTransform<{} | null | undefined, unknown>, z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
-    cwd: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
-    maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-}, z.core.$strip>;
-type GlobInputSchema = z.infer<typeof inputSchema>;
-export declare const createGlobTool: () => {
-    toolDef: {
-        description: string;
-        inputSchema: z.ZodObject<{
-            patterns: z.ZodPipe<z.ZodTransform<{}, unknown>, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-            path: z.ZodPipe<z.ZodTransform<{}, unknown>, z.ZodString>;
-            gitignore: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            expandDirectories: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            ignoreFiles: z.ZodPipe<z.ZodTransform<{} | null | undefined, unknown>, z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
-            cwd: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
-            maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-        }, z.core.$strip>;
-    };
-    display({ patterns, path }: GlobInputSchema): string;
-    execute({ patterns, path, gitignore, recursive, expandDirectories, ignoreFiles, cwd, maxResults, }: GlobInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
-};
-export {};
-//# sourceMappingURL=glob.d.ts.map

package/dist/tools/glob.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../source/tools/glob.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA6EvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;iBA0EtB,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;gCAMK,eAAe;wGAmBtC,eAAe,mBACD,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CAuCrB,CAAC"}

package/dist/tools/glob.js

@@ -1,159 +0,0 @@
-import * as fs from "node:fs";
-import * as nodePath from "node:path";
-import { z } from "zod";
-import style from "../terminal/style.js";
-import { toDisplayPath } from "../utils/filesystem/path-display.js";
-import { glob } from "../utils/glob.js";
-import { convertNullString } from "../utils/zod.js";
-const DEFAULT_MAX_RESULTS = 100;
-const MAX_STAT_FILES = 1000;
-async function getFileWithStats(filePath, effectivePath) {
-    const fullPath = nodePath.join(effectivePath, filePath);
-    try {
-        const stats = await fs.promises.stat(fullPath);
-        return {
-            path: filePath,
-            mtime: stats.mtime.getTime(),
-        };
-    }
-    catch {
-        return {
-            path: filePath,
-            mtime: 0,
-        };
-    }
-}
-function sortFilesByMtime(files) {
-    return files
-        .sort((a, b) => {
-        if (b.mtime !== a.mtime) {
-            return b.mtime - a.mtime;
-        }
-        return a.path.localeCompare(b.path);
-    })
-        .map((file) => file.path);
-}
-function formatResult(sortedFiles) {
-    return sortedFiles.length > 0
-        ? sortedFiles.join("\n")
-        : "No files found matching the specified patterns.";
-}
-function normalizePatternArray(patterns) {
-    return Array.isArray(patterns) ? patterns : [patterns];
-}
-function buildGlobOptions(effectivePath, gitignore, recursive, expandDirectories, ignoreFiles, cwd) {
-    return {
-        cwd: cwd || effectivePath,
-        ...(gitignore !== null && { gitignore }),
-        ...(recursive !== null && { recursive }),
-        ...(expandDirectories !== null && { expandDirectories }),
-        ...(ignoreFiles !== null && { ignoreFiles }),
-    };
-}
-function limitResults(sortedFiles, effectiveMaxResults) {
-    if (effectiveMaxResults > 0 && sortedFiles.length > effectiveMaxResults) {
-        return sortedFiles.slice(0, effectiveMaxResults);
-    }
-    return sortedFiles;
-}
-export const GlobTool = {
-    name: "Glob",
-};
-export const inputSchema = z.object({
-    patterns: z
-        .preprocess((val) => {
-        if (val === null || val === undefined) {
-            return "**/*";
-        }
-        if (typeof val === "string") {
-            const trimmed = val.trim();
-            if (trimmed.startsWith("[")) {
-                try {
-                    const parsed = JSON.parse(trimmed);
-                    if (Array.isArray(parsed)) {
-                        return parsed;
-                    }
-                }
-                catch {
-                    // Not valid JSON, treat as a plain glob string
-                }
-            }
-        }
-        return val;
-    }, z.union([z.string(), z.array(z.string())]))
-        .describe("Glob patterns to search for (e.g., '*.ts', '**/*.test.ts', 'src/**/*.js')"),
-    path: z
-        .preprocess((val) => (val === null || val === undefined ? process.cwd() : val), z.string())
-        .describe("Base directory to search in"),
-    gitignore: z
-        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
-        .describe("Respect ignore patterns in .gitignore files. (default: true)"),
-    recursive: z
-        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
-        .describe("Search recursively. (default: true)"),
-    expandDirectories: z
-        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
-        .describe("Automatically expand directories to files. (default: true)"),
-    ignoreFiles: z
-        .preprocess((val) => {
-        const converted = convertNullString(val);
-        if (converted === null) {
-            return null;
-        }
-        if (typeof converted === "string") {
-            const trimmed = converted.trim();
-            if (trimmed.startsWith("[")) {
-                try {
-                    const parsed = JSON.parse(trimmed);
-                    if (Array.isArray(parsed)) {
-                        return parsed;
-                    }
-                }
-                catch {
-                    // Not valid JSON, treat as a plain string
-                }
-            }
-        }
-        return converted;
-    }, z.union([z.string(), z.array(z.string())]).nullable())
-        .describe("Glob patterns to look for ignore files (e.g., '.gitignore'). Pass null to use default behavior."),
-    cwd: z
-        .preprocess((val) => convertNullString(val), z.coerce.string().nullable())
-        .describe("Current working directory override. (default: process.cwd())"),
-    maxResults: z
-        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
-        .describe("Maximum number of files to return. Set to 0 for no limit. (Default: 100)"),
-});
-export const createGlobTool = () => {
-    return {
-        toolDef: {
-            description: "Find files by name pattern (e.g., *.ts).",
-            inputSchema,
-        },
-        display({ patterns, path }) {
-            const patternArray = Array.isArray(patterns) ? patterns : [patterns];
-            const patternStr = patternArray.length === 1
-                ? patternArray[0]
-                : JSON.stringify(patternArray);
-            const displayPath = toDisplayPath(path);
-            return `${style.cyan(patternStr)} in ${style.cyan(displayPath)}`;
-        },
-        async execute({ patterns, path, gitignore, recursive, expandDirectories, ignoreFiles, cwd, maxResults, }, { abortSignal }) {
-            if (abortSignal?.aborted) {
-                throw new Error("Glob search aborted");
-            }
-            const effectivePath = typeof path === "string" && path.trim() !== "" ? path : process.cwd();
-            const patternArray = normalizePatternArray(patterns);
-            const effectiveMaxResults = maxResults ?? DEFAULT_MAX_RESULTS;
-            const globOptions = buildGlobOptions(effectivePath, gitignore, recursive, expandDirectories, ignoreFiles, cwd);
-            const matchingFiles = await glob(patternArray, globOptions);
-            const filesToStat = matchingFiles.length > MAX_STAT_FILES
-                ? matchingFiles.slice(0, MAX_STAT_FILES)
-                : matchingFiles;
-            const filesWithStats = await Promise.all(filesToStat.map((filePath) => getFileWithStats(filePath, effectivePath)));
-            const sortedFiles = sortFilesByMtime(filesWithStats);
-            const result = limitResults(sortedFiles, effectiveMaxResults);
-            return formatResult(result);
-        },
-    };
-};

package/dist/tools/grep.d.ts

@@ -1,100 +0,0 @@
-import { z } from "zod";
-import type { ToolExecutionOptions } from "./types.ts";
-export declare const GrepTool: {
-    name: "Grep";
-};
-declare const inputSchema: z.ZodObject<{
-    pattern: z.ZodString;
-    path: z.ZodString;
-    recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    ignoreCase: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    filePattern: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
-    contextLines: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    searchIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    literal: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-}, z.core.$strip>;
-type GrepInputSchema = z.infer<typeof inputSchema>;
-export declare const createGrepTool: () => {
-    toolDef: {
-        description: string;
-        inputSchema: z.ZodObject<{
-            pattern: z.ZodString;
-            path: z.ZodString;
-            recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            ignoreCase: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            filePattern: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
-            contextLines: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-            searchIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            literal: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-        }, z.core.$strip>;
-    };
-    display({ pattern, path, filePattern, recursive, ignoreCase, contextLines, }: GrepInputSchema): string;
-    execute({ pattern, path, recursive, ignoreCase, filePattern, contextLines, searchIgnored, literal, maxResults, }: GrepInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
-};
-interface GrepOptions {
-    recursive?: boolean | null;
-    ignoreCase?: boolean | null;
-    filePattern?: string | null;
-    contextLines?: number | null;
-    searchIgnored?: boolean | null;
-    literal?: boolean | null;
-    maxResults?: number | null;
-    likelyUnbalanced?: boolean;
-}
-export declare function likelyUnbalancedRegex(pattern: string): boolean;
-/**
- * Build grep command args array directly
- *
- * @param pattern - The regex pattern to search for
- * @param path - The path to search in
- * @param options - Additional options for the grep command
- * @returns The args array for the grep command
- */
-export declare function buildGrepArgs(pattern: string, path: string, options?: GrepOptions): string[];
-export interface ParsedMatch {
-    file?: string;
-    line: number;
-    content: string;
-    isMatch: boolean;
-    isContext?: boolean;
-    lineNumber?: number;
-    absolutePath?: string;
-    submatches?: Array<{
-        start: number;
-        end: number;
-        text: string;
-    }>;
-}
-interface GrepResult {
-    rawOutput: string;
-    parsedMatches: ParsedMatch[];
-    matchCount: number;
-    displayedCount?: number;
-    contextCount: number;
-    hasMatches: boolean;
-    isTruncated?: boolean;
-}
-/**
- * Parse ripgrep JSON output and extract structured match information
- */
-export declare function parseRipgrepJsonOutput(content: string): ParsedMatch[];
-/**
- * Count actual matches (excluding context lines)
- */
-export declare function countActualMatches(parsed: ParsedMatch[]): number;
-/**
- * Count context lines
- */
-export declare function countContextLines(parsed: ParsedMatch[]): number;
-/**
- * Truncate matches to a maximum number of results, preserving context lines for kept matches
- */
-export declare function truncateMatches(matches: ParsedMatch[], maxResults: number | null | undefined): {
-    truncated: ParsedMatch[];
-    isTruncated: boolean;
-};
-export declare function grepFilesStructured(pattern: string, path: string, options?: GrepOptions, abortSignal?: AbortSignal | null): Promise<GrepResult>;
-export {};
-//# sourceMappingURL=grep.d.ts.map

package/dist/tools/grep.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../source/tools/grep.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;iBAoCf,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;kFAapB,eAAe;sHAoCb,eAAe,mBACD,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CAkErB,CAAC;AAEF,UAAU,WAAW;IACnB,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,aAAa,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAuMD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CA8B9D;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,MAAM,EAAE,CAgEV;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,KAAK,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;CACJ;AAED,UAAU,UAAU;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,CAqDrE;AA8BD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAEhE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAE/D;AAyBD;;GAEG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EAAE,EACtB,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACpC;IAAE,SAAS,EAAE,WAAW,EAAE,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAoDpD;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,EACzB,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI,GAC/B,OAAO,CAAC,UAAU,CAAC,CAgGrB"}