@travisennis/acai 0.0.5 → 0.0.6

package/dist/tools/directory-tree.js

@@ -1,69 +1,67 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { tool } from "ai";
 import { z } from "zod";
-import { config } from "../config.js";
 import style from "../terminal/style.js";
-import { manageOutput } from "../tokens/manage-output.js";
+import { manageTokenLimit } from "../tokens/threshold.js";
 import ignore from "../utils/ignore.js";
 import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
 export const DirectoryTreeTool = {
     name: "directoryTree",
 };
-export const createDirectoryTreeTool = async ({ workingDir, sendData, tokenCounter, }) => {
-    const allowedDirectory = workingDir;
+const inputSchema = z.object({
+    path: z.string().describe("The path."),
+});
+export const createDirectoryTreeTool = async ({ workingDir, allowedDirs, tokenCounter, }) => {
+    const allowedDirectory = allowedDirs ?? [workingDir];
     return {
-        [DirectoryTreeTool.name]: tool({
+        toolDef: {
             description: "Get a directory tree structure for a given path. This tool will ignore any directories or files listed in a .gitignore file. Use this tool when you need to see a complete directory tree for a project. This can be used to get an understanding of how a project is organized and what files are available before using other file system tools.",
-            inputSchema: z.object({
-                path: z.string().describe("The path."),
-            }),
-            execute: async ({ path }, { toolCallId, abortSignal }) => {
+            inputSchema,
+        },
+        async *execute({ path }, { toolCallId, abortSignal }) {
+            try {
                 // Check if execution has been aborted
                 if (abortSignal?.aborted) {
                     throw new Error("Directory tree listing aborted");
                 }
-                let validPath;
-                try {
-                    if (abortSignal?.aborted) {
-                        throw new Error("Directory tree listing aborted before path validation");
-                    }
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-init",
-                        data: `Listing directory tree: ${style.cyan(path)}`,
-                    });
-                    validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory, { abortSignal });
-                    const maxTokens = (await config.readProjectConfig()).tools.maxTokens;
-                    const rawTree = await directoryTree(validPath);
-                    const managed = manageOutput(rawTree, {
-                        tokenCounter,
-                        threshold: maxTokens,
-                    });
-                    if (managed.truncated) {
-                        sendData?.({
-                            id: toolCallId,
-                            event: "tool-update",
-                            data: { primary: managed.warning },
-                        });
-                    }
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-completion",
-                        data: `Done (${managed.tokenCount} tokens)`,
-                    });
-                    return managed.content;
+                yield {
+                    name: DirectoryTreeTool.name,
+                    id: toolCallId,
+                    event: "tool-init",
+                    data: `${style.cyan(path)}`,
+                };
+                const validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory, { abortSignal });
+                if (abortSignal?.aborted) {
+                    throw new Error("Directory tree listing aborted before tree generation");
                 }
-                catch (error) {
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-error",
-                        data: "Failed to show directory tree.",
-                    });
-                    return `Failed to show directory tree: ${error.message}`;
+                const rawTree = await directoryTree(validPath);
+                const result = await manageTokenLimit(rawTree, tokenCounter, "DirectoryTree", "Use excludeDirPatterns or recursive=false to reduce output");
+                // Count files in the tree output
+                const fileCount = (result.content.match(/\n/g) || []).length + 1;
+                let completionMessage = `Found ${fileCount} files`;
+                if (result.truncated) {
+                    completionMessage += ` - ${result.content}`;
                 }
-            },
-        }),
+                completionMessage += ` (${result.tokenCount} tokens)`;
+                yield {
+                    name: DirectoryTreeTool.name,
+                    id: toolCallId,
+                    event: "tool-completion",
+                    data: completionMessage,
+                };
+                yield result.content;
+            }
+            catch (error) {
+                const errorMsg = error.message;
+                yield {
+                    name: DirectoryTreeTool.name,
+                    id: toolCallId,
+                    event: "tool-error",
+                    data: errorMsg,
+                };
+                yield errorMsg;
+            }
+        },
     };
 };
 /**

package/dist/tools/dynamic-tool-loader.d.ts

@@ -1,12 +1,22 @@
+import type { ToolCallOptions } from "ai";
 import { type ToolMetadata } from "./dynamic-tool-parser.ts";
-import type { SendData } from "./types.ts";
-export declare function createDynamicTool(scriptPath: string, metadata: ToolMetadata, sendData?: SendData): {
-    [x: string]: import("ai").Tool<Record<string, unknown>, unknown>;
+import type { ToolResult } from "./types.ts";
+interface DynamicToolObject {
+    toolDef: {
+        description: string;
+        inputSchema: any;
+    };
+    execute: (input: Record<string, unknown>, options: ToolCallOptions) => AsyncGenerator<ToolResult>;
+    ask?: (input: Record<string, unknown>, options: ToolCallOptions) => Promise<{
+        approve: boolean;
+        reason?: string;
+    }>;
+}
+export declare function createDynamicTool(scriptPath: string, metadata: ToolMetadata): {
+    [x: string]: DynamicToolObject;
 };
-export declare function loadDynamicTools({ baseDir, sendData, }: {
+export declare function loadDynamicTools({ baseDir }: {
     baseDir: string;
-    sendData?: SendData;
-}): Promise<Record<string, {
-    [x: string]: import("ai").Tool<Record<string, unknown>, unknown>;
-}>>;
+}): Promise<Record<string, DynamicToolObject>>;
+export {};
 //# sourceMappingURL=dynamic-tool-loader.d.ts.map

package/dist/tools/dynamic-tool-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic-tool-loader.d.ts","sourceRoot":"","sources":["../../source/tools/dynamic-tool-loader.ts"],"names":[],"mappings":"AAQA,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAChF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAwF3C,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,YAAY,EACtB,QAAQ,CAAC,EAAE,QAAQ;;EAuJpB;AAED,wBAAsB,gBAAgB,CAAC,EACrC,OAAO,EACP,QAAQ,GACT,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;;IAgEA"}
+{"version":3,"file":"dynamic-tool-loader.d.ts","sourceRoot":"","sources":["../../source/tools/dynamic-tool-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAI1C,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAChF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AA+K7C,UAAU,iBAAiB;IACzB,OAAO,EAAE;QACP,WAAW,EAAE,MAAM,CAAC;QAEpB,WAAW,EAAE,GAAG,CAAC;KAClB,CAAC;IACF,OAAO,EAAE,CACP,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,eAAe,KACrB,cAAc,CAAC,UAAU,CAAC,CAAC;IAChC,GAAG,CAAC,EAAE,CACJ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,eAAe,KACrB,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrD;AAED,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,YAAY,GACrB;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAAA;CAAE,CAmEpC;AAED,wBAAsB,gBAAgB,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,8CAgEtE"}

package/dist/tools/dynamic-tool-loader.js

@@ -2,7 +2,6 @@ import { spawn } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { tool } from "ai";
 import { z } from "zod";
 import { config } from "../config.js";
 import { logger } from "../logger.js";
@@ -85,143 +84,136 @@ async function getMetadata(scriptPath) {
         });
     });
 }
-export function createDynamicTool(scriptPath, metadata, sendData) {
+async function spawnChildProcess(scriptPath, params, abortSignal) {
+    const paramsArray = Object.entries(params).map(([name, value]) => ({
+        name,
+        value,
+    }));
+    const paramsJson = JSON.stringify(paramsArray);
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [scriptPath], {
+            cwd: path.dirname(scriptPath),
+            env: {
+                ...process.env,
+                // biome-ignore lint/style/useNamingConvention: Environment variables are conventionally uppercase
+                TOOL_ACTION: "execute",
+                // biome-ignore lint/style/useNamingConvention: Environment variables are conventionally uppercase
+                NODE_ENV: "production",
+            },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let hasTimedOut = false;
+        const timer = setTimeout(() => {
+            hasTimedOut = true;
+            child.kill();
+            reject(new Error("Execution timed out after 30 seconds"));
+        }, 30000);
+        child.stdin.write(`${paramsJson}\n`);
+        child.stdin.end();
+        child.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        child.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        child.on("close", () => {
+            clearTimeout(timer);
+            if (hasTimedOut)
+                return;
+            let output = stdout.trim();
+            const maxOutputBytes = 2000000;
+            if (output.length > maxOutputBytes) {
+                output = `${output.substring(0, maxOutputBytes)}\n[Output truncated]`;
+            }
+            // If no stdout, prefer stderr so callers get useful info
+            const errText = stderr.trim();
+            if (!output && errText) {
+                output = errText;
+            }
+            // Fallback to a non-empty placeholder to satisfy callers
+            if (!output) {
+                output = "[No output from dynamic tool]";
+            }
+            // Attempt to parse as JSON if structured
+            if (output && (output.startsWith("{") || output.startsWith("["))) {
+                try {
+                    resolve(JSON.stringify(JSON.parse(output)));
+                }
+                catch {
+                    resolve(output);
+                }
+            }
+            else {
+                resolve(output);
+            }
+        });
+        if (abortSignal) {
+            abortSignal.addEventListener("abort", () => {
+                child.kill();
+            });
+        }
+    });
+}
+export function createDynamicTool(scriptPath, metadata) {
     const inputSchema = generateZodSchema(metadata.parameters);
     const toolName = `dynamic-${metadata.name}`;
     return {
-        [toolName]: tool({
-            description: metadata.description,
-            inputSchema,
-            execute: async (params, { toolCallId, abortSignal }) => {
-                if (abortSignal?.aborted) {
-                    throw new Error("Execution aborted");
-                }
-                sendData?.({
-                    id: toolCallId,
-                    event: "tool-init",
-                    data: `Executing dynamic tool: ${metadata.name}`,
-                });
-                // Validate params again for safety
+        [toolName]: {
+            toolDef: {
+                description: metadata.description,
+                inputSchema,
+            },
+            async *execute(input, { toolCallId, abortSignal }) {
                 try {
-                    inputSchema.parse(params);
-                }
-                catch (e) {
-                    const errMsg = `Invalid parameters for tool ${metadata.name}: ${e.message}`;
-                    sendData?.({
+                    if (abortSignal?.aborted) {
+                        throw new Error("Execution aborted");
+                    }
+                    yield {
+                        name: metadata.name,
+                        event: "tool-init",
                         id: toolCallId,
-                        event: "tool-error",
-                        data: errMsg,
-                    });
-                    throw new Error(errMsg);
-                }
-                const paramsArray = Object.entries(params).map(([name, value]) => ({
-                    name,
-                    value,
-                }));
-                const paramsJson = JSON.stringify(paramsArray);
-                return new Promise((resolve) => {
-                    const child = spawn(process.execPath, [scriptPath], {
-                        cwd: path.dirname(scriptPath),
-                        env: {
-                            ...process.env,
-                            // biome-ignore lint/style/useNamingConvention: Environment variables are conventionally uppercase
-                            TOOL_ACTION: "execute",
-                            // biome-ignore lint/style/useNamingConvention: Environment variables are conventionally uppercase
-                            NODE_ENV: "production",
-                        },
-                        stdio: ["pipe", "pipe", "pipe"],
-                    });
-                    let stdout = "";
-                    let stderr = "";
-                    let hasTimedOut = false;
-                    const timer = setTimeout(() => {
-                        hasTimedOut = true;
-                        child.kill();
-                        sendData?.({
+                        data: "Running",
+                    };
+                    // Validate params again for safety
+                    try {
+                        inputSchema.parse(input);
+                    }
+                    catch (e) {
+                        const errMsg = `Invalid parameters for tool ${metadata.name}: ${e.message}`;
+                        yield {
+                            name: metadata.name,
+                            event: "tool-error",
                             id: toolCallId,
-                            event: "tool-update",
-                            data: { primary: "Execution timed out after 30 seconds" },
-                        });
-                        resolve("Execution timed out after 30 seconds");
-                    }, 30000);
-                    child.stdin.write(`${paramsJson}\n`);
-                    child.stdin.end();
-                    child.stdout.on("data", (data) => {
-                        stdout += data.toString();
-                    });
-                    child.stderr.on("data", (data) => {
-                        stderr += data.toString();
-                    });
-                    child.on("close", (code) => {
-                        clearTimeout(timer);
-                        if (hasTimedOut)
-                            return;
-                        if (code !== 0) {
-                            const errorMsg = `Dynamic tool ${metadata.name} failed: ${stderr || `Exited with code ${code}`}`;
-                            sendData?.({
-                                id: toolCallId,
-                                event: "tool-error",
-                                data: errorMsg,
-                            });
-                            resolve(errorMsg);
-                        }
-                        else {
-                            let output = stdout.trim();
-                            const maxOutputBytes = 2000000;
-                            if (output.length > maxOutputBytes) {
-                                output = `${output.substring(0, maxOutputBytes)}\n[Output truncated]`;
-                            }
-                            // If no stdout, prefer stderr so callers get useful info
-                            const errText = stderr.trim();
-                            if (!output && errText) {
-                                output = errText;
-                            }
-                            // Fallback to a non-empty placeholder to satisfy callers
-                            if (!output) {
-                                output = `[No output from dynamic tool ${metadata.name}]`;
-                            }
-                            // Send tool-update event with last 20 lines of output
-                            const outputLines = output.split("\n");
-                            const lastLines = outputLines.slice(-20).join("\n");
-                            sendData?.({
-                                id: toolCallId,
-                                event: "tool-update",
-                                data: {
-                                    primary: `Last 20 lines of output from ${metadata.name}:`,
-                                    secondary: lastLines.split("\n"),
-                                },
-                            });
-                            // Attempt to parse as JSON if structured
-                            if (output &&
-                                (output.startsWith("{") || output.startsWith("["))) {
-                                try {
-                                    resolve(JSON.parse(output));
-                                }
-                                catch {
-                                    resolve(output);
-                                }
-                            }
-                            else {
-                                resolve(output);
-                            }
-                            sendData?.({
-                                id: toolCallId,
-                                event: "tool-completion",
-                                data: `Dynamic tool ${metadata.name} completed`,
-                            });
-                        }
-                    });
-                    if (abortSignal) {
-                        abortSignal.addEventListener("abort", () => {
-                            child.kill();
-                        });
+                            data: errMsg,
+                        };
+                        yield errMsg;
+                        return;
                     }
-                });
+                    const result = await spawnChildProcess(scriptPath, input, abortSignal);
+                    yield {
+                        name: metadata.name,
+                        event: "tool-completion",
+                        id: toolCallId,
+                        data: "Completed",
+                    };
+                    yield result;
+                }
+                catch (error) {
+                    yield {
+                        name: metadata.name,
+                        event: "tool-error",
+                        id: toolCallId,
+                        data: `${metadata.name}: ${error.message}`,
+                    };
+                    yield error.message;
+                }
             },
-        }),
+        },
     };
 }
-export async function loadDynamicTools({ baseDir, sendData, }) {
+export async function loadDynamicTools({ baseDir }) {
     const projectConfig = await config.readProjectConfig();
     const dynamicConfig = projectConfig.tools.dynamicTools;
     if (!dynamicConfig.enabled) {
@@ -274,7 +266,7 @@ export async function loadDynamicTools({ baseDir, sendData, }) {
     }
     const tools = {};
     for (const [_, { path, metadata }] of toolMap) {
-        Object.assign(tools, createDynamicTool(path, metadata, sendData));
+        Object.assign(tools, createDynamicTool(path, metadata));
     }
     return tools;
 }

package/dist/tools/dynamic-tool-parser.d.ts

@@ -13,6 +13,7 @@ declare const toolMetadataSchema: z.ZodObject<{
         required: z.ZodDefault<z.ZodBoolean>;
         default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
     }, z.core.$strip>>;
+    needsApproval: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type ToolMetadata = z.infer<typeof toolMetadataSchema>;
 export declare function parseToolMetadata(output: string): ToolMetadata;

package/dist/tools/dynamic-tool-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic-tool-parser.d.ts","sourceRoot":"","sources":["../../source/tools/dynamic-tool-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;iBAYtB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAS9D"}
+{"version":3,"file":"dynamic-tool-parser.d.ts","sourceRoot":"","sources":["../../source/tools/dynamic-tool-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;iBAatB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAS9D"}

package/dist/tools/dynamic-tool-parser.js

@@ -9,6 +9,7 @@ const toolMetadataSchema = z.object({
         required: z.boolean().default(true),
         default: z.union([z.string(), z.number(), z.boolean()]).optional(),
     })),
+    needsApproval: z.boolean().default(true),
 });
 export function parseToolMetadata(output) {
     try {

package/dist/tools/edit-file.d.ts

@@ -1,27 +1,47 @@
-import type { Terminal } from "../terminal/index.ts";
-import type { ToolExecutor } from "../tool-executor.ts";
-import type { SendData } from "./types.ts";
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
+import type { ModelManager } from "../models/manager.ts";
+import type { TokenTracker } from "../tokens/tracker.ts";
+import type { ToolResult } from "./types.ts";
 export declare const EditFileTool: {
     name: "editFile";
 };
-export declare const createEditFileTool: ({ workingDir, terminal, sendData, toolExecutor, }: {
+declare const inputSchema: z.ZodObject<{
+    path: z.ZodString;
+    edits: z.ZodArray<z.ZodObject<{
+        oldText: z.ZodString;
+        newText: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type EditFileInputSchema = z.infer<typeof inputSchema>;
+export declare const createEditFileTool: ({ workingDir, allowedDirs, modelManager, tokenTracker, enableLlmFix, }: {
     workingDir: string;
-    terminal?: Terminal;
-    sendData?: SendData;
-    toolExecutor?: ToolExecutor;
+    allowedDirs?: string[];
+    modelManager?: ModelManager;
+    tokenTracker?: TokenTracker;
+    enableLlmFix?: boolean;
 }) => Promise<{
-    editFile: import("ai").Tool<{
-        path: string;
-        edits: {
-            oldText: string;
-            newText: string;
-        }[];
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            path: z.ZodString;
+            edits: z.ZodArray<z.ZodObject<{
+                oldText: z.ZodString;
+                newText: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    execute({ path, edits }: EditFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 }>;
 interface FileEdit {
     oldText: string;
     newText: string;
 }
-export declare function applyFileEdits(filePath: string, edits: FileEdit[], dryRun?: boolean, abortSignal?: AbortSignal): Promise<string>;
+export declare function applyFileEdits(filePath: string, edits: FileEdit[], dryRun?: boolean, abortSignal?: AbortSignal, options?: {
+    modelManager?: ModelManager;
+    tokenTracker?: TokenTracker;
+    enableLlmFix?: boolean;
+    instruction?: string;
+}): Promise<string>;
 export {};
 //# sourceMappingURL=edit-file.d.ts.map

package/dist/tools/edit-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edit-file.d.ts","sourceRoot":"","sources":["../../source/tools/edit-file.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,KAAK,EAAe,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAErE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,mDAKtC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;;;;;;;;EA+JA,CAAC;AAyBF,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,UAAQ,EACd,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,MAAM,CAAC,CAmEjB"}
+{"version":3,"file":"edit-file.d.ts","sourceRoot":"","sources":["../../source/tools/edit-file.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAE1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;iBAcf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,wEAMtC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;;;;;;;;;;;6BAcsB,mBAAmB,+BACP,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAkDhC,CAAC;AAyBF,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,UAAQ,EACd,WAAW,CAAC,EAAE,WAAW,EACzB,OAAO,CAAC,EAAE;IACR,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GACA,OAAO,CAAC,MAAM,CAAC,CA2DjB"}